genmodel 0.0.41 → 0.0.42
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.
- checksums.yaml +4 -4
- data/ext/Genmodel/Genmodel.cpp +3338 -411
- metadata +1 -1
data/ext/Genmodel/Genmodel.cpp
CHANGED
@@ -1835,28 +1835,27 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
|
|
1835
1835
|
#define SWIGTYPE_p_std__allocatorT_long_t swig_types[27]
|
1836
1836
|
#define SWIGTYPE_p_std__allocatorT_size_t_t swig_types[28]
|
1837
1837
|
#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[29]
|
1838
|
-
#define
|
1839
|
-
#define
|
1840
|
-
#define
|
1841
|
-
#define
|
1842
|
-
#define
|
1843
|
-
#define
|
1844
|
-
#define
|
1845
|
-
#define
|
1846
|
-
#define
|
1847
|
-
#define
|
1848
|
-
#define
|
1849
|
-
#define
|
1850
|
-
#define
|
1851
|
-
#define
|
1852
|
-
#define
|
1853
|
-
#define
|
1854
|
-
#define
|
1855
|
-
#define
|
1856
|
-
#define
|
1857
|
-
|
1858
|
-
static
|
1859
|
-
static swig_module_info swig_module = {swig_types, 50, 0, 0, 0, 0};
|
1838
|
+
#define SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[30]
|
1839
|
+
#define SWIGTYPE_p_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t swig_types[31]
|
1840
|
+
#define SWIGTYPE_p_std__vectorT_HyperGen_std__allocatorT_HyperGen_t_t swig_types[32]
|
1841
|
+
#define SWIGTYPE_p_std__vectorT_ModConsts_std__allocatorT_ModConsts_t_t swig_types[33]
|
1842
|
+
#define SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t swig_types[34]
|
1843
|
+
#define SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t swig_types[35]
|
1844
|
+
#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[36]
|
1845
|
+
#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[37]
|
1846
|
+
#define SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t swig_types[38]
|
1847
|
+
#define SWIGTYPE_p_std__vectorT_size_t_std__allocatorT_size_t_t_t swig_types[39]
|
1848
|
+
#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[40]
|
1849
|
+
#define SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t swig_types[41]
|
1850
|
+
#define SWIGTYPE_p_std__vectorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t_t swig_types[42]
|
1851
|
+
#define SWIGTYPE_p_string swig_types[43]
|
1852
|
+
#define SWIGTYPE_p_swig__ConstIterator swig_types[44]
|
1853
|
+
#define SWIGTYPE_p_swig__GC_VALUE swig_types[45]
|
1854
|
+
#define SWIGTYPE_p_swig__Iterator swig_types[46]
|
1855
|
+
#define SWIGTYPE_p_value_type swig_types[47]
|
1856
|
+
#define SWIGTYPE_p_void swig_types[48]
|
1857
|
+
static swig_type_info *swig_types[50];
|
1858
|
+
static swig_module_info swig_module = {swig_types, 49, 0, 0, 0, 0};
|
1860
1859
|
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
|
1861
1860
|
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
|
1862
1861
|
|
@@ -5689,6 +5688,307 @@ SWIGINTERN VALUE std_vector_Sl_double_Sg____delete__(std::vector< double > *self
|
|
5689
5688
|
return r;
|
5690
5689
|
}
|
5691
5690
|
|
5691
|
+
namespace swig {
|
5692
|
+
template <> struct traits<std::vector<std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
|
5693
|
+
typedef pointer_category category;
|
5694
|
+
static const char* type_name() {
|
5695
|
+
return "std::vector<" "std::vector< double,std::allocator< double > >" "," "std::allocator< std::vector< double,std::allocator< double > > >" " >";
|
5696
|
+
}
|
5697
|
+
};
|
5698
|
+
}
|
5699
|
+
|
5700
|
+
SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg__dup(std::vector< std::vector< double > > *self){
|
5701
|
+
return new std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >(*self);
|
5702
|
+
}
|
5703
|
+
SWIGINTERN VALUE std_vector_Sl_std_vector_Sl_double_Sg__Sg__inspect(std::vector< std::vector< double > > *self){
|
5704
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::const_iterator i = self->begin();
|
5705
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::const_iterator e = self->end();
|
5706
|
+
const char *type_name = swig::type_name< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > >();
|
5707
|
+
VALUE str = rb_str_new2(type_name);
|
5708
|
+
str = rb_str_cat2( str, " [" );
|
5709
|
+
bool comma = false;
|
5710
|
+
VALUE tmp;
|
5711
|
+
for ( ; i != e; ++i, comma = true )
|
5712
|
+
{
|
5713
|
+
if (comma) str = rb_str_cat2( str, "," );
|
5714
|
+
tmp = swig::from< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type >( *i );
|
5715
|
+
tmp = rb_inspect( tmp );
|
5716
|
+
str = rb_str_buf_append( str, tmp );
|
5717
|
+
}
|
5718
|
+
str = rb_str_cat2( str, "]" );
|
5719
|
+
return str;
|
5720
|
+
}
|
5721
|
+
SWIGINTERN VALUE std_vector_Sl_std_vector_Sl_double_Sg__Sg__to_a(std::vector< std::vector< double > > *self){
|
5722
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::const_iterator i = self->begin();
|
5723
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::const_iterator e = self->end();
|
5724
|
+
VALUE ary = rb_ary_new2( std::distance( i, e ) );
|
5725
|
+
VALUE tmp;
|
5726
|
+
for ( ; i != e; ++i )
|
5727
|
+
{
|
5728
|
+
tmp = swig::from< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type >( *i );
|
5729
|
+
rb_ary_push( ary, tmp );
|
5730
|
+
}
|
5731
|
+
return ary;
|
5732
|
+
}
|
5733
|
+
SWIGINTERN VALUE std_vector_Sl_std_vector_Sl_double_Sg__Sg__to_s(std::vector< std::vector< double > > *self){
|
5734
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::iterator i = self->begin();
|
5735
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::iterator e = self->end();
|
5736
|
+
VALUE str = rb_str_new2( "" );
|
5737
|
+
VALUE tmp;
|
5738
|
+
for ( ; i != e; ++i )
|
5739
|
+
{
|
5740
|
+
tmp = swig::from< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type >( *i );
|
5741
|
+
tmp = rb_obj_as_string( tmp );
|
5742
|
+
str = rb_str_buf_append( str, tmp );
|
5743
|
+
}
|
5744
|
+
return str;
|
5745
|
+
}
|
5746
|
+
SWIGINTERN VALUE std_vector_Sl_std_vector_Sl_double_Sg__Sg__slice(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
|
5747
|
+
if ( j <= 0 ) return Qnil;
|
5748
|
+
std::size_t len = self->size();
|
5749
|
+
if ( i < 0 ) i = len - i;
|
5750
|
+
j += i;
|
5751
|
+
if ( static_cast<std::size_t>(j) >= len ) j = len-1;
|
5752
|
+
|
5753
|
+
VALUE r = Qnil;
|
5754
|
+
try {
|
5755
|
+
r = swig::from< const std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >* >( swig::getslice(self, i, j) );
|
5756
|
+
}
|
5757
|
+
catch( std::out_of_range )
|
5758
|
+
{
|
5759
|
+
}
|
5760
|
+
return r;
|
5761
|
+
}
|
5762
|
+
SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg__each(std::vector< std::vector< double > > *self){
|
5763
|
+
if ( !rb_block_given_p() )
|
5764
|
+
rb_raise( rb_eArgError, "no block given");
|
5765
|
+
|
5766
|
+
VALUE r;
|
5767
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::const_iterator i = self->begin();
|
5768
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::const_iterator e = self->end();
|
5769
|
+
for ( ; i != e; ++i )
|
5770
|
+
{
|
5771
|
+
r = swig::from< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type >(*i);
|
5772
|
+
rb_yield(r);
|
5773
|
+
}
|
5774
|
+
|
5775
|
+
return self;
|
5776
|
+
}
|
5777
|
+
SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg__select(std::vector< std::vector< double > > *self){
|
5778
|
+
if ( !rb_block_given_p() )
|
5779
|
+
rb_raise( rb_eArgError, "no block given" );
|
5780
|
+
|
5781
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >* r = new std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >;
|
5782
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::const_iterator i = self->begin();
|
5783
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::const_iterator e = self->end();
|
5784
|
+
for ( ; i != e; ++i )
|
5785
|
+
{
|
5786
|
+
VALUE v = swig::from< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type >(*i);
|
5787
|
+
if ( RTEST( rb_yield(v) ) )
|
5788
|
+
self->insert( r->end(), *i);
|
5789
|
+
}
|
5790
|
+
|
5791
|
+
return r;
|
5792
|
+
}
|
5793
|
+
SWIGINTERN VALUE std_vector_Sl_std_vector_Sl_double_Sg__Sg__delete_at(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
|
5794
|
+
VALUE r = Qnil;
|
5795
|
+
try {
|
5796
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::iterator at = swig::getpos(self, i);
|
5797
|
+
r = swig::from< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type >( *(at) );
|
5798
|
+
self->erase(at);
|
5799
|
+
}
|
5800
|
+
catch (std::out_of_range)
|
5801
|
+
{
|
5802
|
+
}
|
5803
|
+
return r;
|
5804
|
+
}
|
5805
|
+
SWIGINTERN VALUE std_vector_Sl_std_vector_Sl_double_Sg__Sg____delete2__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::value_type const &i){
|
5806
|
+
VALUE r = Qnil;
|
5807
|
+
return r;
|
5808
|
+
}
|
5809
|
+
SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg__reject_bang(std::vector< std::vector< double > > *self){
|
5810
|
+
if ( !rb_block_given_p() )
|
5811
|
+
rb_raise( rb_eArgError, "no block given" );
|
5812
|
+
|
5813
|
+
self->erase( std::remove_if( self->begin(), self->end(),
|
5814
|
+
swig::yield< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type >() ), self->end() );
|
5815
|
+
return self;
|
5816
|
+
}
|
5817
|
+
SWIGINTERN VALUE std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
|
5818
|
+
if (self->empty()) return Qnil;
|
5819
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
|
5820
|
+
self->pop_back();
|
5821
|
+
return swig::from< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type >( x );
|
5822
|
+
}
|
5823
|
+
SWIGINTERN std::vector< std::vector< double > >::value_type const std_vector_Sl_std_vector_Sl_double_Sg__Sg__push(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::value_type const &e){
|
5824
|
+
self->push_back( e );
|
5825
|
+
return e;
|
5826
|
+
}
|
5827
|
+
SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg__reject(std::vector< std::vector< double > > *self){
|
5828
|
+
if ( !rb_block_given_p() )
|
5829
|
+
rb_raise( rb_eArgError, "no block given" );
|
5830
|
+
|
5831
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >* r = new std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >;
|
5832
|
+
std::remove_copy_if( self->begin(), self->end(),
|
5833
|
+
std::back_inserter(*r),
|
5834
|
+
swig::yield< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type >() );
|
5835
|
+
return r;
|
5836
|
+
}
|
5837
|
+
SWIGINTERN VALUE std_vector_Sl_std_vector_Sl_double_Sg__Sg__at(std::vector< std::vector< double > > const *self,std::vector< std::vector< double > >::difference_type i){
|
5838
|
+
VALUE r = Qnil;
|
5839
|
+
try {
|
5840
|
+
r = swig::from< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type >( *(swig::cgetpos(self, i)) );
|
5841
|
+
}
|
5842
|
+
catch( std::out_of_range )
|
5843
|
+
{
|
5844
|
+
}
|
5845
|
+
return r;
|
5846
|
+
}
|
5847
|
+
SWIGINTERN VALUE std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > const *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
|
5848
|
+
if ( j <= 0 ) return Qnil;
|
5849
|
+
std::size_t len = self->size();
|
5850
|
+
if ( i < 0 ) i = len - i;
|
5851
|
+
j += i; if ( static_cast<std::size_t>(j) >= len ) j = len-1;
|
5852
|
+
|
5853
|
+
VALUE r = Qnil;
|
5854
|
+
try {
|
5855
|
+
r = swig::from< const std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >* >( swig::getslice(self, i, j) );
|
5856
|
+
}
|
5857
|
+
catch( std::out_of_range )
|
5858
|
+
{
|
5859
|
+
}
|
5860
|
+
return r;
|
5861
|
+
}
|
5862
|
+
SWIGINTERN VALUE std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::vector< double > > const *self,std::vector< std::vector< double > >::difference_type i){
|
5863
|
+
VALUE r = Qnil;
|
5864
|
+
try {
|
5865
|
+
r = swig::from< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type >( *(swig::cgetpos(self, i)) );
|
5866
|
+
}
|
5867
|
+
catch( std::out_of_range )
|
5868
|
+
{
|
5869
|
+
}
|
5870
|
+
return r;
|
5871
|
+
}
|
5872
|
+
SWIGINTERN VALUE std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_2(std::vector< std::vector< double > > const *self,VALUE i){
|
5873
|
+
if ( rb_obj_is_kind_of( i, rb_cRange ) == Qfalse )
|
5874
|
+
{
|
5875
|
+
rb_raise( rb_eTypeError, "not a valid index or range" );
|
5876
|
+
}
|
5877
|
+
|
5878
|
+
VALUE r = Qnil;
|
5879
|
+
static ID id_end = rb_intern("end");
|
5880
|
+
static ID id_start = rb_intern("begin");
|
5881
|
+
static ID id_noend = rb_intern("exclude_end?");
|
5882
|
+
|
5883
|
+
VALUE start = rb_funcall( i, id_start, 0 );
|
5884
|
+
VALUE end = rb_funcall( i, id_end, 0 );
|
5885
|
+
bool noend = ( rb_funcall( i, id_noend, 0 ) == Qtrue );
|
5886
|
+
|
5887
|
+
int len = self->size();
|
5888
|
+
|
5889
|
+
int s = NUM2INT( start );
|
5890
|
+
if ( s < 0 ) s = len + s;
|
5891
|
+
else if ( s >= len ) return Qnil;
|
5892
|
+
|
5893
|
+
int e = NUM2INT( end );
|
5894
|
+
if ( e < 0 ) e = len + e;
|
5895
|
+
|
5896
|
+
if ( e < s ) return Qnil; //std::swap( s, e );
|
5897
|
+
|
5898
|
+
if ( noend ) e -= 1;
|
5899
|
+
if ( e >= len ) e = len - 1;
|
5900
|
+
|
5901
|
+
return swig::from< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >* >( swig::getslice(self, s, e+1) );
|
5902
|
+
}
|
5903
|
+
SWIGINTERN VALUE std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::value_type const &x){
|
5904
|
+
std::size_t len = self->size();
|
5905
|
+
if ( i < 0 ) i = len - i;
|
5906
|
+
else if ( static_cast<std::size_t>(i) >= len )
|
5907
|
+
self->resize( i+1, x );
|
5908
|
+
else
|
5909
|
+
*(swig::getpos(self,i)) = x;
|
5910
|
+
|
5911
|
+
return swig::from< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type >( x );
|
5912
|
+
}
|
5913
|
+
SWIGINTERN VALUE std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
|
5914
|
+
|
5915
|
+
if ( j <= 0 ) return Qnil;
|
5916
|
+
std::size_t len = self->size();
|
5917
|
+
if ( i < 0 ) i = len - i;
|
5918
|
+
j += i;
|
5919
|
+
if ( static_cast<std::size_t>(j) >= len ) {
|
5920
|
+
self->resize( j+1, *(v.begin()) );
|
5921
|
+
j = len-1;
|
5922
|
+
}
|
5923
|
+
|
5924
|
+
VALUE r = Qnil;
|
5925
|
+
swig::setslice(self, i, j, v);
|
5926
|
+
r = swig::from< const std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >* >( &v );
|
5927
|
+
return r;
|
5928
|
+
}
|
5929
|
+
SWIGINTERN VALUE std_vector_Sl_std_vector_Sl_double_Sg__Sg__shift(std::vector< std::vector< double > > *self){
|
5930
|
+
if (self->empty()) return Qnil;
|
5931
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->front();
|
5932
|
+
self->erase( self->begin() );
|
5933
|
+
return swig::from< std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type >( x );
|
5934
|
+
}
|
5935
|
+
SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type pos,int argc,VALUE *argv,...){
|
5936
|
+
std::size_t len = self->size();
|
5937
|
+
std::size_t i = swig::check_index( pos, len, true );
|
5938
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::iterator start;
|
5939
|
+
|
5940
|
+
VALUE elem = argv[0];
|
5941
|
+
int idx = 0;
|
5942
|
+
try {
|
5943
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type val = swig::as<std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type>( elem, true );
|
5944
|
+
if ( i >= len ) {
|
5945
|
+
self->resize(i-1, val);
|
5946
|
+
return self;
|
5947
|
+
}
|
5948
|
+
start = self->begin();
|
5949
|
+
std::advance( start, i );
|
5950
|
+
self->insert( start++, val );
|
5951
|
+
|
5952
|
+
for ( ++idx; idx < argc; ++idx )
|
5953
|
+
{
|
5954
|
+
elem = argv[idx];
|
5955
|
+
val = swig::as<std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type>( elem );
|
5956
|
+
self->insert( start++, val );
|
5957
|
+
}
|
5958
|
+
|
5959
|
+
}
|
5960
|
+
catch( std::invalid_argument )
|
5961
|
+
{
|
5962
|
+
rb_raise( rb_eArgError, "%s",
|
5963
|
+
Ruby_Format_TypeError( "",
|
5964
|
+
swig::type_name<std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type>(),
|
5965
|
+
__FUNCTION__, idx+2, elem ));
|
5966
|
+
}
|
5967
|
+
|
5968
|
+
|
5969
|
+
return self;
|
5970
|
+
}
|
5971
|
+
SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg__unshift(std::vector< std::vector< double > > *self,int argc,VALUE *argv,...){
|
5972
|
+
for ( int idx = argc-1; idx >= 0; --idx )
|
5973
|
+
{
|
5974
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::iterator start = self->begin();
|
5975
|
+
VALUE elem = argv[idx];
|
5976
|
+
try {
|
5977
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type val = swig::as<std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type>( elem, true );
|
5978
|
+
self->insert( start, val );
|
5979
|
+
}
|
5980
|
+
catch( std::invalid_argument )
|
5981
|
+
{
|
5982
|
+
rb_raise( rb_eArgError, "%s",
|
5983
|
+
Ruby_Format_TypeError( "",
|
5984
|
+
swig::type_name<std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type>(),
|
5985
|
+
__FUNCTION__, idx+2, elem ));
|
5986
|
+
}
|
5987
|
+
}
|
5988
|
+
|
5989
|
+
return self;
|
5990
|
+
}
|
5991
|
+
|
5692
5992
|
SWIGINTERN int
|
5693
5993
|
SWIG_AsVal_bool (VALUE obj, bool *val)
|
5694
5994
|
{
|
@@ -21648,36 +21948,36 @@ free_std_vector_Sl_double_Sg_(std::vector< double > *arg1) {
|
|
21648
21948
|
delete arg1;
|
21649
21949
|
}
|
21650
21950
|
|
21651
|
-
static swig_class
|
21951
|
+
static swig_class SwigClassDoubleVector2d;
|
21652
21952
|
|
21653
21953
|
|
21654
21954
|
/*
|
21655
|
-
Document-method: Genmodel::
|
21955
|
+
Document-method: Genmodel::DoubleVector2d.dup
|
21656
21956
|
|
21657
21957
|
call-seq:
|
21658
|
-
dup ->
|
21958
|
+
dup -> DoubleVector2d
|
21659
21959
|
|
21660
21960
|
Create a duplicate of the class and unfreeze it if needed.
|
21661
21961
|
*/
|
21662
21962
|
SWIGINTERN VALUE
|
21663
|
-
|
21664
|
-
std::vector<
|
21963
|
+
_wrap_DoubleVector2d_dup(int argc, VALUE *argv, VALUE self) {
|
21964
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
21665
21965
|
void *argp1 = 0 ;
|
21666
21966
|
int res1 = 0 ;
|
21667
|
-
std::vector<
|
21967
|
+
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
|
21668
21968
|
VALUE vresult = Qnil;
|
21669
21969
|
|
21670
21970
|
if ((argc < 0) || (argc > 0)) {
|
21671
21971
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
21672
21972
|
}
|
21673
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
21973
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
21674
21974
|
if (!SWIG_IsOK(res1)) {
|
21675
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
21975
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","dup", 1, self ));
|
21676
21976
|
}
|
21677
|
-
arg1 = reinterpret_cast< std::vector<
|
21977
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
21678
21978
|
{
|
21679
21979
|
try {
|
21680
|
-
result = (std::vector<
|
21980
|
+
result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg__dup(arg1);
|
21681
21981
|
}
|
21682
21982
|
catch(string str) {
|
21683
21983
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -21686,7 +21986,7 @@ _wrap_BoolVector_dup(int argc, VALUE *argv, VALUE self) {
|
|
21686
21986
|
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
21687
21987
|
}
|
21688
21988
|
}
|
21689
|
-
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result),
|
21989
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_OWN | 0 );
|
21690
21990
|
return vresult;
|
21691
21991
|
fail:
|
21692
21992
|
return Qnil;
|
@@ -21695,7 +21995,7 @@ fail:
|
|
21695
21995
|
|
21696
21996
|
|
21697
21997
|
/*
|
21698
|
-
Document-method: Genmodel::
|
21998
|
+
Document-method: Genmodel::DoubleVector2d.inspect
|
21699
21999
|
|
21700
22000
|
call-seq:
|
21701
22001
|
inspect -> VALUE
|
@@ -21703,8 +22003,8 @@ fail:
|
|
21703
22003
|
Inspect class and its contents.
|
21704
22004
|
*/
|
21705
22005
|
SWIGINTERN VALUE
|
21706
|
-
|
21707
|
-
std::vector<
|
22006
|
+
_wrap_DoubleVector2d_inspect(int argc, VALUE *argv, VALUE self) {
|
22007
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
21708
22008
|
void *argp1 = 0 ;
|
21709
22009
|
int res1 = 0 ;
|
21710
22010
|
VALUE result;
|
@@ -21713,14 +22013,14 @@ _wrap_BoolVector_inspect(int argc, VALUE *argv, VALUE self) {
|
|
21713
22013
|
if ((argc < 0) || (argc > 0)) {
|
21714
22014
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
21715
22015
|
}
|
21716
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22016
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
21717
22017
|
if (!SWIG_IsOK(res1)) {
|
21718
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22018
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","inspect", 1, self ));
|
21719
22019
|
}
|
21720
|
-
arg1 = reinterpret_cast< std::vector<
|
22020
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
21721
22021
|
{
|
21722
22022
|
try {
|
21723
|
-
result = (VALUE)
|
22023
|
+
result = (VALUE)std_vector_Sl_std_vector_Sl_double_Sg__Sg__inspect(arg1);
|
21724
22024
|
}
|
21725
22025
|
catch(string str) {
|
21726
22026
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -21738,16 +22038,16 @@ fail:
|
|
21738
22038
|
|
21739
22039
|
|
21740
22040
|
/*
|
21741
|
-
Document-method: Genmodel::
|
22041
|
+
Document-method: Genmodel::DoubleVector2d.to_a
|
21742
22042
|
|
21743
22043
|
call-seq:
|
21744
22044
|
to_a -> VALUE
|
21745
22045
|
|
21746
|
-
Convert
|
22046
|
+
Convert DoubleVector2d to an Array.
|
21747
22047
|
*/
|
21748
22048
|
SWIGINTERN VALUE
|
21749
|
-
|
21750
|
-
std::vector<
|
22049
|
+
_wrap_DoubleVector2d_to_a(int argc, VALUE *argv, VALUE self) {
|
22050
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
21751
22051
|
void *argp1 = 0 ;
|
21752
22052
|
int res1 = 0 ;
|
21753
22053
|
VALUE result;
|
@@ -21756,14 +22056,14 @@ _wrap_BoolVector_to_a(int argc, VALUE *argv, VALUE self) {
|
|
21756
22056
|
if ((argc < 0) || (argc > 0)) {
|
21757
22057
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
21758
22058
|
}
|
21759
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22059
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
21760
22060
|
if (!SWIG_IsOK(res1)) {
|
21761
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22061
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","to_a", 1, self ));
|
21762
22062
|
}
|
21763
|
-
arg1 = reinterpret_cast< std::vector<
|
22063
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
21764
22064
|
{
|
21765
22065
|
try {
|
21766
|
-
result = (VALUE)
|
22066
|
+
result = (VALUE)std_vector_Sl_std_vector_Sl_double_Sg__Sg__to_a(arg1);
|
21767
22067
|
}
|
21768
22068
|
catch(string str) {
|
21769
22069
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -21781,7 +22081,7 @@ fail:
|
|
21781
22081
|
|
21782
22082
|
|
21783
22083
|
/*
|
21784
|
-
Document-method: Genmodel::
|
22084
|
+
Document-method: Genmodel::DoubleVector2d.to_s
|
21785
22085
|
|
21786
22086
|
call-seq:
|
21787
22087
|
to_s -> VALUE
|
@@ -21789,8 +22089,8 @@ fail:
|
|
21789
22089
|
Convert class to a String representation.
|
21790
22090
|
*/
|
21791
22091
|
SWIGINTERN VALUE
|
21792
|
-
|
21793
|
-
std::vector<
|
22092
|
+
_wrap_DoubleVector2d_to_s(int argc, VALUE *argv, VALUE self) {
|
22093
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
21794
22094
|
void *argp1 = 0 ;
|
21795
22095
|
int res1 = 0 ;
|
21796
22096
|
VALUE result;
|
@@ -21799,14 +22099,14 @@ _wrap_BoolVector_to_s(int argc, VALUE *argv, VALUE self) {
|
|
21799
22099
|
if ((argc < 0) || (argc > 0)) {
|
21800
22100
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
21801
22101
|
}
|
21802
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22102
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
21803
22103
|
if (!SWIG_IsOK(res1)) {
|
21804
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22104
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","to_s", 1, self ));
|
21805
22105
|
}
|
21806
|
-
arg1 = reinterpret_cast< std::vector<
|
22106
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
21807
22107
|
{
|
21808
22108
|
try {
|
21809
|
-
result = (VALUE)
|
22109
|
+
result = (VALUE)std_vector_Sl_std_vector_Sl_double_Sg__Sg__to_s(arg1);
|
21810
22110
|
}
|
21811
22111
|
catch(string str) {
|
21812
22112
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -21824,18 +22124,18 @@ fail:
|
|
21824
22124
|
|
21825
22125
|
|
21826
22126
|
/*
|
21827
|
-
Document-method: Genmodel::
|
22127
|
+
Document-method: Genmodel::DoubleVector2d.slice
|
21828
22128
|
|
21829
22129
|
call-seq:
|
21830
22130
|
slice(i, j) -> VALUE
|
21831
22131
|
|
21832
|
-
Return a slice (portion of) the
|
22132
|
+
Return a slice (portion of) the DoubleVector2d.
|
21833
22133
|
*/
|
21834
22134
|
SWIGINTERN VALUE
|
21835
|
-
|
21836
|
-
std::vector<
|
21837
|
-
std::vector<
|
21838
|
-
std::vector<
|
22135
|
+
_wrap_DoubleVector2d_slice(int argc, VALUE *argv, VALUE self) {
|
22136
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
22137
|
+
std::vector< std::vector< double > >::difference_type arg2 ;
|
22138
|
+
std::vector< std::vector< double > >::difference_type arg3 ;
|
21839
22139
|
void *argp1 = 0 ;
|
21840
22140
|
int res1 = 0 ;
|
21841
22141
|
ptrdiff_t val2 ;
|
@@ -21848,24 +22148,24 @@ _wrap_BoolVector_slice(int argc, VALUE *argv, VALUE self) {
|
|
21848
22148
|
if ((argc < 2) || (argc > 2)) {
|
21849
22149
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
21850
22150
|
}
|
21851
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22151
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
21852
22152
|
if (!SWIG_IsOK(res1)) {
|
21853
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22153
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","slice", 1, self ));
|
21854
22154
|
}
|
21855
|
-
arg1 = reinterpret_cast< std::vector<
|
22155
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
21856
22156
|
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
21857
22157
|
if (!SWIG_IsOK(ecode2)) {
|
21858
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector<
|
22158
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::difference_type","slice", 2, argv[0] ));
|
21859
22159
|
}
|
21860
|
-
arg2 = static_cast< std::vector<
|
22160
|
+
arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
|
21861
22161
|
ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
|
21862
22162
|
if (!SWIG_IsOK(ecode3)) {
|
21863
|
-
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector<
|
22163
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::difference_type","slice", 3, argv[1] ));
|
21864
22164
|
}
|
21865
|
-
arg3 = static_cast< std::vector<
|
22165
|
+
arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
|
21866
22166
|
{
|
21867
22167
|
try {
|
21868
|
-
result = (VALUE)
|
22168
|
+
result = (VALUE)std_vector_Sl_std_vector_Sl_double_Sg__Sg__slice(arg1,arg2,arg3);
|
21869
22169
|
}
|
21870
22170
|
catch(string str) {
|
21871
22171
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -21883,32 +22183,32 @@ fail:
|
|
21883
22183
|
|
21884
22184
|
|
21885
22185
|
/*
|
21886
|
-
Document-method: Genmodel::
|
22186
|
+
Document-method: Genmodel::DoubleVector2d.each
|
21887
22187
|
|
21888
22188
|
call-seq:
|
21889
|
-
each ->
|
22189
|
+
each -> DoubleVector2d
|
21890
22190
|
|
21891
|
-
Iterate thru each element in the
|
22191
|
+
Iterate thru each element in the DoubleVector2d. A block must be provided.
|
21892
22192
|
*/
|
21893
22193
|
SWIGINTERN VALUE
|
21894
|
-
|
21895
|
-
std::vector<
|
22194
|
+
_wrap_DoubleVector2d_each(int argc, VALUE *argv, VALUE self) {
|
22195
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
21896
22196
|
void *argp1 = 0 ;
|
21897
22197
|
int res1 = 0 ;
|
21898
|
-
std::vector<
|
22198
|
+
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
|
21899
22199
|
VALUE vresult = Qnil;
|
21900
22200
|
|
21901
22201
|
if ((argc < 0) || (argc > 0)) {
|
21902
22202
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
21903
22203
|
}
|
21904
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22204
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
21905
22205
|
if (!SWIG_IsOK(res1)) {
|
21906
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22206
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","each", 1, self ));
|
21907
22207
|
}
|
21908
|
-
arg1 = reinterpret_cast< std::vector<
|
22208
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
21909
22209
|
{
|
21910
22210
|
try {
|
21911
|
-
result = (std::vector<
|
22211
|
+
result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg__each(arg1);
|
21912
22212
|
}
|
21913
22213
|
catch(string str) {
|
21914
22214
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -21917,7 +22217,7 @@ _wrap_BoolVector_each(int argc, VALUE *argv, VALUE self) {
|
|
21917
22217
|
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
21918
22218
|
}
|
21919
22219
|
}
|
21920
|
-
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result),
|
22220
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
21921
22221
|
return vresult;
|
21922
22222
|
fail:
|
21923
22223
|
return Qnil;
|
@@ -21926,32 +22226,32 @@ fail:
|
|
21926
22226
|
|
21927
22227
|
|
21928
22228
|
/*
|
21929
|
-
Document-method: Genmodel::
|
22229
|
+
Document-method: Genmodel::DoubleVector2d.select
|
21930
22230
|
|
21931
22231
|
call-seq:
|
21932
|
-
select ->
|
22232
|
+
select -> DoubleVector2d
|
21933
22233
|
|
21934
|
-
Iterate thru each element in the
|
22234
|
+
Iterate thru each element in the DoubleVector2d and select those that match a condition. A block must be provided.
|
21935
22235
|
*/
|
21936
22236
|
SWIGINTERN VALUE
|
21937
|
-
|
21938
|
-
std::vector<
|
22237
|
+
_wrap_DoubleVector2d_select(int argc, VALUE *argv, VALUE self) {
|
22238
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
21939
22239
|
void *argp1 = 0 ;
|
21940
22240
|
int res1 = 0 ;
|
21941
|
-
std::vector<
|
22241
|
+
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
|
21942
22242
|
VALUE vresult = Qnil;
|
21943
22243
|
|
21944
22244
|
if ((argc < 0) || (argc > 0)) {
|
21945
22245
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
21946
22246
|
}
|
21947
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22247
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
21948
22248
|
if (!SWIG_IsOK(res1)) {
|
21949
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22249
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","select", 1, self ));
|
21950
22250
|
}
|
21951
|
-
arg1 = reinterpret_cast< std::vector<
|
22251
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
21952
22252
|
{
|
21953
22253
|
try {
|
21954
|
-
result = (std::vector<
|
22254
|
+
result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg__select(arg1);
|
21955
22255
|
}
|
21956
22256
|
catch(string str) {
|
21957
22257
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -21960,7 +22260,7 @@ _wrap_BoolVector_select(int argc, VALUE *argv, VALUE self) {
|
|
21960
22260
|
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
21961
22261
|
}
|
21962
22262
|
}
|
21963
|
-
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result),
|
22263
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_OWN | 0 );
|
21964
22264
|
return vresult;
|
21965
22265
|
fail:
|
21966
22266
|
return Qnil;
|
@@ -21969,7 +22269,7 @@ fail:
|
|
21969
22269
|
|
21970
22270
|
|
21971
22271
|
/*
|
21972
|
-
Document-method: Genmodel::
|
22272
|
+
Document-method: Genmodel::DoubleVector2d.delete_at
|
21973
22273
|
|
21974
22274
|
call-seq:
|
21975
22275
|
delete_at(i) -> VALUE
|
@@ -21977,9 +22277,9 @@ fail:
|
|
21977
22277
|
Delete an element at a certain index.
|
21978
22278
|
*/
|
21979
22279
|
SWIGINTERN VALUE
|
21980
|
-
|
21981
|
-
std::vector<
|
21982
|
-
std::vector<
|
22280
|
+
_wrap_DoubleVector2d_delete_at(int argc, VALUE *argv, VALUE self) {
|
22281
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
22282
|
+
std::vector< std::vector< double > >::difference_type arg2 ;
|
21983
22283
|
void *argp1 = 0 ;
|
21984
22284
|
int res1 = 0 ;
|
21985
22285
|
ptrdiff_t val2 ;
|
@@ -21990,19 +22290,19 @@ _wrap_BoolVector_delete_at(int argc, VALUE *argv, VALUE self) {
|
|
21990
22290
|
if ((argc < 1) || (argc > 1)) {
|
21991
22291
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
21992
22292
|
}
|
21993
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22293
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
21994
22294
|
if (!SWIG_IsOK(res1)) {
|
21995
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22295
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","delete_at", 1, self ));
|
21996
22296
|
}
|
21997
|
-
arg1 = reinterpret_cast< std::vector<
|
22297
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
21998
22298
|
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
21999
22299
|
if (!SWIG_IsOK(ecode2)) {
|
22000
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector<
|
22300
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::difference_type","delete_at", 2, argv[0] ));
|
22001
22301
|
}
|
22002
|
-
arg2 = static_cast< std::vector<
|
22302
|
+
arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
|
22003
22303
|
{
|
22004
22304
|
try {
|
22005
|
-
result = (VALUE)
|
22305
|
+
result = (VALUE)std_vector_Sl_std_vector_Sl_double_Sg__Sg__delete_at(arg1,arg2);
|
22006
22306
|
}
|
22007
22307
|
catch(string str) {
|
22008
22308
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -22019,34 +22319,37 @@ fail:
|
|
22019
22319
|
|
22020
22320
|
|
22021
22321
|
SWIGINTERN VALUE
|
22022
|
-
|
22023
|
-
std::vector<
|
22024
|
-
std::vector<
|
22322
|
+
_wrap_DoubleVector2d___delete2__(int argc, VALUE *argv, VALUE self) {
|
22323
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
22324
|
+
std::vector< std::vector< double > >::value_type *arg2 = 0 ;
|
22025
22325
|
void *argp1 = 0 ;
|
22026
22326
|
int res1 = 0 ;
|
22027
|
-
|
22028
|
-
bool val2 ;
|
22029
|
-
int ecode2 = 0 ;
|
22327
|
+
int res2 = SWIG_OLDOBJ ;
|
22030
22328
|
VALUE result;
|
22031
22329
|
VALUE vresult = Qnil;
|
22032
22330
|
|
22033
22331
|
if ((argc < 1) || (argc > 1)) {
|
22034
22332
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
22035
22333
|
}
|
22036
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22334
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
22037
22335
|
if (!SWIG_IsOK(res1)) {
|
22038
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22336
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","__delete2__", 1, self ));
|
22337
|
+
}
|
22338
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
22339
|
+
{
|
22340
|
+
std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
|
22341
|
+
res2 = swig::asptr(argv[0], &ptr);
|
22342
|
+
if (!SWIG_IsOK(res2)) {
|
22343
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::value_type const &","__delete2__", 2, argv[0] ));
|
22344
|
+
}
|
22345
|
+
if (!ptr) {
|
22346
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::vector< double > >::value_type const &","__delete2__", 2, argv[0]));
|
22347
|
+
}
|
22348
|
+
arg2 = ptr;
|
22039
22349
|
}
|
22040
|
-
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
22041
|
-
ecode2 = SWIG_AsVal_bool(argv[0], &val2);
|
22042
|
-
if (!SWIG_IsOK(ecode2)) {
|
22043
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< bool >::value_type","__delete2__", 2, argv[0] ));
|
22044
|
-
}
|
22045
|
-
temp2 = static_cast< std::vector< bool >::value_type >(val2);
|
22046
|
-
arg2 = &temp2;
|
22047
22350
|
{
|
22048
22351
|
try {
|
22049
|
-
result = (VALUE)
|
22352
|
+
result = (VALUE)std_vector_Sl_std_vector_Sl_double_Sg__Sg____delete2__(arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
|
22050
22353
|
}
|
22051
22354
|
catch(string str) {
|
22052
22355
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -22056,40 +22359,42 @@ _wrap_BoolVector___delete2__(int argc, VALUE *argv, VALUE self) {
|
|
22056
22359
|
}
|
22057
22360
|
}
|
22058
22361
|
vresult = result;
|
22362
|
+
if (SWIG_IsNewObj(res2)) delete arg2;
|
22059
22363
|
return vresult;
|
22060
22364
|
fail:
|
22365
|
+
if (SWIG_IsNewObj(res2)) delete arg2;
|
22061
22366
|
return Qnil;
|
22062
22367
|
}
|
22063
22368
|
|
22064
22369
|
|
22065
22370
|
|
22066
22371
|
/*
|
22067
|
-
Document-method: Genmodel::
|
22372
|
+
Document-method: Genmodel::DoubleVector2d.reject!
|
22068
22373
|
|
22069
22374
|
call-seq:
|
22070
|
-
reject! ->
|
22375
|
+
reject! -> DoubleVector2d
|
22071
22376
|
|
22072
|
-
Iterate thru each element in the
|
22377
|
+
Iterate thru each element in the DoubleVector2d and reject those that fail a condition. A block must be provided. DoubleVector2d is modified in place.
|
22073
22378
|
*/
|
22074
22379
|
SWIGINTERN VALUE
|
22075
|
-
|
22076
|
-
std::vector<
|
22380
|
+
_wrap_DoubleVector2d_rejectN___(int argc, VALUE *argv, VALUE self) {
|
22381
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
22077
22382
|
void *argp1 = 0 ;
|
22078
22383
|
int res1 = 0 ;
|
22079
|
-
std::vector<
|
22384
|
+
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
|
22080
22385
|
VALUE vresult = Qnil;
|
22081
22386
|
|
22082
22387
|
if ((argc < 0) || (argc > 0)) {
|
22083
22388
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
22084
22389
|
}
|
22085
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22390
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
22086
22391
|
if (!SWIG_IsOK(res1)) {
|
22087
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22392
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","reject_bang", 1, self ));
|
22088
22393
|
}
|
22089
|
-
arg1 = reinterpret_cast< std::vector<
|
22394
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
22090
22395
|
{
|
22091
22396
|
try {
|
22092
|
-
result = (std::vector<
|
22397
|
+
result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg__reject_bang(arg1);
|
22093
22398
|
}
|
22094
22399
|
catch(string str) {
|
22095
22400
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -22098,7 +22403,7 @@ _wrap_BoolVector_rejectN___(int argc, VALUE *argv, VALUE self) {
|
|
22098
22403
|
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
22099
22404
|
}
|
22100
22405
|
}
|
22101
|
-
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result),
|
22406
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
22102
22407
|
return vresult;
|
22103
22408
|
fail:
|
22104
22409
|
return Qnil;
|
@@ -22107,16 +22412,16 @@ fail:
|
|
22107
22412
|
|
22108
22413
|
|
22109
22414
|
/*
|
22110
|
-
Document-method: Genmodel::
|
22415
|
+
Document-method: Genmodel::DoubleVector2d.pop
|
22111
22416
|
|
22112
22417
|
call-seq:
|
22113
22418
|
pop -> VALUE
|
22114
22419
|
|
22115
|
-
Remove and return element at the end of the
|
22420
|
+
Remove and return element at the end of the DoubleVector2d.
|
22116
22421
|
*/
|
22117
22422
|
SWIGINTERN VALUE
|
22118
|
-
|
22119
|
-
std::vector<
|
22423
|
+
_wrap_DoubleVector2d_pop(int argc, VALUE *argv, VALUE self) {
|
22424
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
22120
22425
|
void *argp1 = 0 ;
|
22121
22426
|
int res1 = 0 ;
|
22122
22427
|
VALUE result;
|
@@ -22125,14 +22430,14 @@ _wrap_BoolVector_pop(int argc, VALUE *argv, VALUE self) {
|
|
22125
22430
|
if ((argc < 0) || (argc > 0)) {
|
22126
22431
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
22127
22432
|
}
|
22128
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22433
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
22129
22434
|
if (!SWIG_IsOK(res1)) {
|
22130
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22435
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","pop", 1, self ));
|
22131
22436
|
}
|
22132
|
-
arg1 = reinterpret_cast< std::vector<
|
22437
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
22133
22438
|
{
|
22134
22439
|
try {
|
22135
|
-
result = (VALUE)
|
22440
|
+
result = (VALUE)std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(arg1);
|
22136
22441
|
}
|
22137
22442
|
catch(string str) {
|
22138
22443
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -22150,42 +22455,45 @@ fail:
|
|
22150
22455
|
|
22151
22456
|
|
22152
22457
|
/*
|
22153
|
-
Document-method: Genmodel::
|
22458
|
+
Document-method: Genmodel::DoubleVector2d.push
|
22154
22459
|
|
22155
22460
|
call-seq:
|
22156
|
-
push(e) ->
|
22461
|
+
push(e) -> DoubleVector
|
22157
22462
|
|
22158
|
-
Add an element at the end of the
|
22463
|
+
Add an element at the end of the DoubleVector2d.
|
22159
22464
|
*/
|
22160
22465
|
SWIGINTERN VALUE
|
22161
|
-
|
22162
|
-
std::vector<
|
22163
|
-
std::vector<
|
22466
|
+
_wrap_DoubleVector2d_push(int argc, VALUE *argv, VALUE self) {
|
22467
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
22468
|
+
std::vector< std::vector< double > >::value_type *arg2 = 0 ;
|
22164
22469
|
void *argp1 = 0 ;
|
22165
22470
|
int res1 = 0 ;
|
22166
|
-
|
22167
|
-
|
22168
|
-
int ecode2 = 0 ;
|
22169
|
-
std::vector< bool >::value_type result;
|
22471
|
+
int res2 = SWIG_OLDOBJ ;
|
22472
|
+
std::vector< std::vector< double > >::value_type result;
|
22170
22473
|
VALUE vresult = Qnil;
|
22171
22474
|
|
22172
22475
|
if ((argc < 1) || (argc > 1)) {
|
22173
22476
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
22174
22477
|
}
|
22175
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22478
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
22176
22479
|
if (!SWIG_IsOK(res1)) {
|
22177
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22480
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","push", 1, self ));
|
22481
|
+
}
|
22482
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
22483
|
+
{
|
22484
|
+
std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
|
22485
|
+
res2 = swig::asptr(argv[0], &ptr);
|
22486
|
+
if (!SWIG_IsOK(res2)) {
|
22487
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::value_type const &","push", 2, argv[0] ));
|
22488
|
+
}
|
22489
|
+
if (!ptr) {
|
22490
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::vector< double > >::value_type const &","push", 2, argv[0]));
|
22491
|
+
}
|
22492
|
+
arg2 = ptr;
|
22178
22493
|
}
|
22179
|
-
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
22180
|
-
ecode2 = SWIG_AsVal_bool(argv[0], &val2);
|
22181
|
-
if (!SWIG_IsOK(ecode2)) {
|
22182
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< bool >::value_type","push", 2, argv[0] ));
|
22183
|
-
}
|
22184
|
-
temp2 = static_cast< std::vector< bool >::value_type >(val2);
|
22185
|
-
arg2 = &temp2;
|
22186
22494
|
{
|
22187
22495
|
try {
|
22188
|
-
result = (std::vector<
|
22496
|
+
result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__push(arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
|
22189
22497
|
}
|
22190
22498
|
catch(string str) {
|
22191
22499
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -22194,41 +22502,43 @@ _wrap_BoolVector_push(int argc, VALUE *argv, VALUE self) {
|
|
22194
22502
|
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
22195
22503
|
}
|
22196
22504
|
}
|
22197
|
-
vresult =
|
22505
|
+
vresult = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
|
22506
|
+
if (SWIG_IsNewObj(res2)) delete arg2;
|
22198
22507
|
return vresult;
|
22199
22508
|
fail:
|
22509
|
+
if (SWIG_IsNewObj(res2)) delete arg2;
|
22200
22510
|
return Qnil;
|
22201
22511
|
}
|
22202
22512
|
|
22203
22513
|
|
22204
22514
|
|
22205
22515
|
/*
|
22206
|
-
Document-method: Genmodel::
|
22516
|
+
Document-method: Genmodel::DoubleVector2d.reject
|
22207
22517
|
|
22208
22518
|
call-seq:
|
22209
|
-
reject ->
|
22519
|
+
reject -> DoubleVector2d
|
22210
22520
|
|
22211
|
-
Iterate thru each element in the
|
22521
|
+
Iterate thru each element in the DoubleVector2d and reject those that fail a condition returning a new DoubleVector2d. A block must be provided.
|
22212
22522
|
*/
|
22213
22523
|
SWIGINTERN VALUE
|
22214
|
-
|
22215
|
-
std::vector<
|
22524
|
+
_wrap_DoubleVector2d_reject(int argc, VALUE *argv, VALUE self) {
|
22525
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
22216
22526
|
void *argp1 = 0 ;
|
22217
22527
|
int res1 = 0 ;
|
22218
|
-
std::vector<
|
22528
|
+
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
|
22219
22529
|
VALUE vresult = Qnil;
|
22220
22530
|
|
22221
22531
|
if ((argc < 0) || (argc > 0)) {
|
22222
22532
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
22223
22533
|
}
|
22224
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22534
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
22225
22535
|
if (!SWIG_IsOK(res1)) {
|
22226
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22536
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","reject", 1, self ));
|
22227
22537
|
}
|
22228
|
-
arg1 = reinterpret_cast< std::vector<
|
22538
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
22229
22539
|
{
|
22230
22540
|
try {
|
22231
|
-
result = (std::vector<
|
22541
|
+
result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg__reject(arg1);
|
22232
22542
|
}
|
22233
22543
|
catch(string str) {
|
22234
22544
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -22237,7 +22547,7 @@ _wrap_BoolVector_reject(int argc, VALUE *argv, VALUE self) {
|
|
22237
22547
|
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
22238
22548
|
}
|
22239
22549
|
}
|
22240
|
-
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result),
|
22550
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, SWIG_POINTER_OWN | 0 );
|
22241
22551
|
return vresult;
|
22242
22552
|
fail:
|
22243
22553
|
return Qnil;
|
@@ -22246,7 +22556,7 @@ fail:
|
|
22246
22556
|
|
22247
22557
|
|
22248
22558
|
/*
|
22249
|
-
Document-method: Genmodel::
|
22559
|
+
Document-method: Genmodel::DoubleVector2d.at
|
22250
22560
|
|
22251
22561
|
call-seq:
|
22252
22562
|
at(i) -> VALUE
|
@@ -22254,9 +22564,9 @@ fail:
|
|
22254
22564
|
Return element at a certain index.
|
22255
22565
|
*/
|
22256
22566
|
SWIGINTERN VALUE
|
22257
|
-
|
22258
|
-
std::vector<
|
22259
|
-
std::vector<
|
22567
|
+
_wrap_DoubleVector2d_at(int argc, VALUE *argv, VALUE self) {
|
22568
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
22569
|
+
std::vector< std::vector< double > >::difference_type arg2 ;
|
22260
22570
|
void *argp1 = 0 ;
|
22261
22571
|
int res1 = 0 ;
|
22262
22572
|
ptrdiff_t val2 ;
|
@@ -22267,19 +22577,19 @@ _wrap_BoolVector_at(int argc, VALUE *argv, VALUE self) {
|
|
22267
22577
|
if ((argc < 1) || (argc > 1)) {
|
22268
22578
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
22269
22579
|
}
|
22270
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22580
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
22271
22581
|
if (!SWIG_IsOK(res1)) {
|
22272
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22582
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > const *","at", 1, self ));
|
22273
22583
|
}
|
22274
|
-
arg1 = reinterpret_cast< std::vector<
|
22584
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
22275
22585
|
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
22276
22586
|
if (!SWIG_IsOK(ecode2)) {
|
22277
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector<
|
22587
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::difference_type","at", 2, argv[0] ));
|
22278
22588
|
}
|
22279
|
-
arg2 = static_cast< std::vector<
|
22589
|
+
arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
|
22280
22590
|
{
|
22281
22591
|
try {
|
22282
|
-
result = (VALUE)
|
22592
|
+
result = (VALUE)std_vector_Sl_std_vector_Sl_double_Sg__Sg__at((std::vector< std::vector< double > > const *)arg1,arg2);
|
22283
22593
|
}
|
22284
22594
|
catch(string str) {
|
22285
22595
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -22297,7 +22607,7 @@ fail:
|
|
22297
22607
|
|
22298
22608
|
|
22299
22609
|
/*
|
22300
|
-
Document-method: Genmodel::
|
22610
|
+
Document-method: Genmodel::DoubleVector2d.[]
|
22301
22611
|
|
22302
22612
|
call-seq:
|
22303
22613
|
[](i, j) -> VALUE
|
@@ -22307,10 +22617,10 @@ fail:
|
|
22307
22617
|
Element accessor/slicing.
|
22308
22618
|
*/
|
22309
22619
|
SWIGINTERN VALUE
|
22310
|
-
|
22311
|
-
std::vector<
|
22312
|
-
std::vector<
|
22313
|
-
std::vector<
|
22620
|
+
_wrap_DoubleVector2d___getitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
|
22621
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
22622
|
+
std::vector< std::vector< double > >::difference_type arg2 ;
|
22623
|
+
std::vector< std::vector< double > >::difference_type arg3 ;
|
22314
22624
|
void *argp1 = 0 ;
|
22315
22625
|
int res1 = 0 ;
|
22316
22626
|
ptrdiff_t val2 ;
|
@@ -22323,24 +22633,24 @@ _wrap_BoolVector___getitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
|
|
22323
22633
|
if ((argc < 2) || (argc > 2)) {
|
22324
22634
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
22325
22635
|
}
|
22326
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22636
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
22327
22637
|
if (!SWIG_IsOK(res1)) {
|
22328
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22638
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > const *","__getitem__", 1, self ));
|
22329
22639
|
}
|
22330
|
-
arg1 = reinterpret_cast< std::vector<
|
22640
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
22331
22641
|
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
22332
22642
|
if (!SWIG_IsOK(ecode2)) {
|
22333
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector<
|
22643
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::difference_type","__getitem__", 2, argv[0] ));
|
22334
22644
|
}
|
22335
|
-
arg2 = static_cast< std::vector<
|
22645
|
+
arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
|
22336
22646
|
ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
|
22337
22647
|
if (!SWIG_IsOK(ecode3)) {
|
22338
|
-
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector<
|
22648
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::difference_type","__getitem__", 3, argv[1] ));
|
22339
22649
|
}
|
22340
|
-
arg3 = static_cast< std::vector<
|
22650
|
+
arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
|
22341
22651
|
{
|
22342
22652
|
try {
|
22343
|
-
result = (VALUE)
|
22653
|
+
result = (VALUE)std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0((std::vector< std::vector< double > > const *)arg1,arg2,arg3);
|
22344
22654
|
}
|
22345
22655
|
catch(string str) {
|
22346
22656
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -22357,9 +22667,9 @@ fail:
|
|
22357
22667
|
|
22358
22668
|
|
22359
22669
|
SWIGINTERN VALUE
|
22360
|
-
|
22361
|
-
std::vector<
|
22362
|
-
std::vector<
|
22670
|
+
_wrap_DoubleVector2d___getitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
|
22671
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
22672
|
+
std::vector< std::vector< double > >::difference_type arg2 ;
|
22363
22673
|
void *argp1 = 0 ;
|
22364
22674
|
int res1 = 0 ;
|
22365
22675
|
ptrdiff_t val2 ;
|
@@ -22370,19 +22680,19 @@ _wrap_BoolVector___getitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
|
|
22370
22680
|
if ((argc < 1) || (argc > 1)) {
|
22371
22681
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
22372
22682
|
}
|
22373
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22683
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
22374
22684
|
if (!SWIG_IsOK(res1)) {
|
22375
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22685
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > const *","__getitem__", 1, self ));
|
22376
22686
|
}
|
22377
|
-
arg1 = reinterpret_cast< std::vector<
|
22687
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
22378
22688
|
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
22379
22689
|
if (!SWIG_IsOK(ecode2)) {
|
22380
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector<
|
22690
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::difference_type","__getitem__", 2, argv[0] ));
|
22381
22691
|
}
|
22382
|
-
arg2 = static_cast< std::vector<
|
22692
|
+
arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
|
22383
22693
|
{
|
22384
22694
|
try {
|
22385
|
-
result = (VALUE)
|
22695
|
+
result = (VALUE)std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_1((std::vector< std::vector< double > > const *)arg1,arg2);
|
22386
22696
|
}
|
22387
22697
|
catch(string str) {
|
22388
22698
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -22399,8 +22709,8 @@ fail:
|
|
22399
22709
|
|
22400
22710
|
|
22401
22711
|
SWIGINTERN VALUE
|
22402
|
-
|
22403
|
-
std::vector<
|
22712
|
+
_wrap_DoubleVector2d___getitem____SWIG_2(int argc, VALUE *argv, VALUE self) {
|
22713
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
22404
22714
|
VALUE arg2 = (VALUE) 0 ;
|
22405
22715
|
void *argp1 = 0 ;
|
22406
22716
|
int res1 = 0 ;
|
@@ -22410,15 +22720,15 @@ _wrap_BoolVector___getitem____SWIG_2(int argc, VALUE *argv, VALUE self) {
|
|
22410
22720
|
if ((argc < 1) || (argc > 1)) {
|
22411
22721
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
22412
22722
|
}
|
22413
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22723
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
22414
22724
|
if (!SWIG_IsOK(res1)) {
|
22415
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22725
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > const *","__getitem__", 1, self ));
|
22416
22726
|
}
|
22417
|
-
arg1 = reinterpret_cast< std::vector<
|
22727
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
22418
22728
|
arg2 = argv[0];
|
22419
22729
|
{
|
22420
22730
|
try {
|
22421
|
-
result = (VALUE)
|
22731
|
+
result = (VALUE)std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_2((std::vector< std::vector< double > > const *)arg1,arg2);
|
22422
22732
|
}
|
22423
22733
|
catch(string str) {
|
22424
22734
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -22434,7 +22744,7 @@ fail:
|
|
22434
22744
|
}
|
22435
22745
|
|
22436
22746
|
|
22437
|
-
SWIGINTERN VALUE
|
22747
|
+
SWIGINTERN VALUE _wrap_DoubleVector2d___getitem__(int nargs, VALUE *args, VALUE self) {
|
22438
22748
|
int argc;
|
22439
22749
|
VALUE argv[4];
|
22440
22750
|
int ii;
|
@@ -22447,7 +22757,7 @@ SWIGINTERN VALUE _wrap_BoolVector___getitem__(int nargs, VALUE *args, VALUE self
|
|
22447
22757
|
}
|
22448
22758
|
if (argc == 2) {
|
22449
22759
|
int _v;
|
22450
|
-
int res = swig::asptr(argv[0], (std::vector<
|
22760
|
+
int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
|
22451
22761
|
_v = SWIG_CheckState(res);
|
22452
22762
|
if (_v) {
|
22453
22763
|
{
|
@@ -22455,24 +22765,24 @@ SWIGINTERN VALUE _wrap_BoolVector___getitem__(int nargs, VALUE *args, VALUE self
|
|
22455
22765
|
_v = SWIG_CheckState(res);
|
22456
22766
|
}
|
22457
22767
|
if (_v) {
|
22458
|
-
return
|
22768
|
+
return _wrap_DoubleVector2d___getitem____SWIG_1(nargs, args, self);
|
22459
22769
|
}
|
22460
22770
|
}
|
22461
22771
|
}
|
22462
22772
|
if (argc == 2) {
|
22463
22773
|
int _v;
|
22464
|
-
int res = swig::asptr(argv[0], (std::vector<
|
22774
|
+
int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
|
22465
22775
|
_v = SWIG_CheckState(res);
|
22466
22776
|
if (_v) {
|
22467
22777
|
_v = (argv[1] != 0);
|
22468
22778
|
if (_v) {
|
22469
|
-
return
|
22779
|
+
return _wrap_DoubleVector2d___getitem____SWIG_2(nargs, args, self);
|
22470
22780
|
}
|
22471
22781
|
}
|
22472
22782
|
}
|
22473
22783
|
if (argc == 3) {
|
22474
22784
|
int _v;
|
22475
|
-
int res = swig::asptr(argv[0], (std::vector<
|
22785
|
+
int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
|
22476
22786
|
_v = SWIG_CheckState(res);
|
22477
22787
|
if (_v) {
|
22478
22788
|
{
|
@@ -22485,7 +22795,7 @@ SWIGINTERN VALUE _wrap_BoolVector___getitem__(int nargs, VALUE *args, VALUE self
|
|
22485
22795
|
_v = SWIG_CheckState(res);
|
22486
22796
|
}
|
22487
22797
|
if (_v) {
|
22488
|
-
return
|
22798
|
+
return _wrap_DoubleVector2d___getitem____SWIG_0(nargs, args, self);
|
22489
22799
|
}
|
22490
22800
|
}
|
22491
22801
|
}
|
@@ -22493,8 +22803,8 @@ SWIGINTERN VALUE _wrap_BoolVector___getitem__(int nargs, VALUE *args, VALUE self
|
|
22493
22803
|
|
22494
22804
|
fail:
|
22495
22805
|
Ruby_Format_OverloadedError( argc, 4, "__getitem__",
|
22496
|
-
" VALUE __getitem__(std::vector<
|
22497
|
-
" VALUE __getitem__(std::vector<
|
22806
|
+
" VALUE __getitem__(std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)\n"
|
22807
|
+
" VALUE __getitem__(std::vector< std::vector< double > >::difference_type i)\n"
|
22498
22808
|
" VALUE __getitem__(VALUE i)\n");
|
22499
22809
|
|
22500
22810
|
return Qnil;
|
@@ -22503,7 +22813,7 @@ fail:
|
|
22503
22813
|
|
22504
22814
|
|
22505
22815
|
/*
|
22506
|
-
Document-method: Genmodel::
|
22816
|
+
Document-method: Genmodel::DoubleVector2d.[]=
|
22507
22817
|
|
22508
22818
|
call-seq:
|
22509
22819
|
[]=(i, x) -> VALUE
|
@@ -22512,42 +22822,45 @@ fail:
|
|
22512
22822
|
Element setter/slicing.
|
22513
22823
|
*/
|
22514
22824
|
SWIGINTERN VALUE
|
22515
|
-
|
22516
|
-
std::vector<
|
22517
|
-
std::vector<
|
22518
|
-
std::vector<
|
22825
|
+
_wrap_DoubleVector2d___setitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
|
22826
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
22827
|
+
std::vector< std::vector< double > >::difference_type arg2 ;
|
22828
|
+
std::vector< std::vector< double > >::value_type *arg3 = 0 ;
|
22519
22829
|
void *argp1 = 0 ;
|
22520
22830
|
int res1 = 0 ;
|
22521
22831
|
ptrdiff_t val2 ;
|
22522
22832
|
int ecode2 = 0 ;
|
22523
|
-
|
22524
|
-
bool val3 ;
|
22525
|
-
int ecode3 = 0 ;
|
22833
|
+
int res3 = SWIG_OLDOBJ ;
|
22526
22834
|
VALUE result;
|
22527
22835
|
VALUE vresult = Qnil;
|
22528
22836
|
|
22529
22837
|
if ((argc < 2) || (argc > 2)) {
|
22530
22838
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
22531
22839
|
}
|
22532
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22840
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
22533
22841
|
if (!SWIG_IsOK(res1)) {
|
22534
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22842
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","__setitem__", 1, self ));
|
22535
22843
|
}
|
22536
|
-
arg1 = reinterpret_cast< std::vector<
|
22844
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
22537
22845
|
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
22538
22846
|
if (!SWIG_IsOK(ecode2)) {
|
22539
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector<
|
22540
|
-
}
|
22541
|
-
arg2 = static_cast< std::vector< bool >::difference_type >(val2);
|
22542
|
-
ecode3 = SWIG_AsVal_bool(argv[1], &val3);
|
22543
|
-
if (!SWIG_IsOK(ecode3)) {
|
22544
|
-
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< bool >::value_type","__setitem__", 3, argv[1] ));
|
22847
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::difference_type","__setitem__", 2, argv[0] ));
|
22545
22848
|
}
|
22546
|
-
|
22547
|
-
|
22849
|
+
arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
|
22850
|
+
{
|
22851
|
+
std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
|
22852
|
+
res3 = swig::asptr(argv[1], &ptr);
|
22853
|
+
if (!SWIG_IsOK(res3)) {
|
22854
|
+
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::value_type const &","__setitem__", 3, argv[1] ));
|
22855
|
+
}
|
22856
|
+
if (!ptr) {
|
22857
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::vector< double > >::value_type const &","__setitem__", 3, argv[1]));
|
22858
|
+
}
|
22859
|
+
arg3 = ptr;
|
22860
|
+
}
|
22548
22861
|
{
|
22549
22862
|
try {
|
22550
|
-
result = (VALUE)
|
22863
|
+
result = (VALUE)std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
|
22551
22864
|
}
|
22552
22865
|
catch(string str) {
|
22553
22866
|
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
@@ -22557,18 +22870,20 @@ _wrap_BoolVector___setitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
|
|
22557
22870
|
}
|
22558
22871
|
}
|
22559
22872
|
vresult = result;
|
22873
|
+
if (SWIG_IsNewObj(res3)) delete arg3;
|
22560
22874
|
return vresult;
|
22561
22875
|
fail:
|
22876
|
+
if (SWIG_IsNewObj(res3)) delete arg3;
|
22562
22877
|
return Qnil;
|
22563
22878
|
}
|
22564
22879
|
|
22565
22880
|
|
22566
22881
|
SWIGINTERN VALUE
|
22567
|
-
|
22568
|
-
std::vector<
|
22569
|
-
std::vector<
|
22570
|
-
std::vector<
|
22571
|
-
std::vector<
|
22882
|
+
_wrap_DoubleVector2d___setitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
|
22883
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
22884
|
+
std::vector< std::vector< double > >::difference_type arg2 ;
|
22885
|
+
std::vector< std::vector< double > >::difference_type arg3 ;
|
22886
|
+
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg4 = 0 ;
|
22572
22887
|
void *argp1 = 0 ;
|
22573
22888
|
int res1 = 0 ;
|
22574
22889
|
ptrdiff_t val2 ;
|
@@ -22582,36 +22897,2660 @@ _wrap_BoolVector___setitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
|
|
22582
22897
|
if ((argc < 3) || (argc > 3)) {
|
22583
22898
|
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
|
22584
22899
|
}
|
22585
|
-
res1 = SWIG_ConvertPtr(self, &argp1,
|
22900
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
22586
22901
|
if (!SWIG_IsOK(res1)) {
|
22587
|
-
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector<
|
22902
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","__setitem__", 1, self ));
|
22588
22903
|
}
|
22589
|
-
arg1 = reinterpret_cast< std::vector<
|
22904
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
22590
22905
|
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
22591
22906
|
if (!SWIG_IsOK(ecode2)) {
|
22592
|
-
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector<
|
22907
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::difference_type","__setitem__", 2, argv[0] ));
|
22593
22908
|
}
|
22594
|
-
arg2 = static_cast< std::vector<
|
22909
|
+
arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
|
22595
22910
|
ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
|
22596
22911
|
if (!SWIG_IsOK(ecode3)) {
|
22597
|
-
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector<
|
22912
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::difference_type","__setitem__", 3, argv[1] ));
|
22598
22913
|
}
|
22599
|
-
arg3 = static_cast< std::vector<
|
22914
|
+
arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
|
22600
22915
|
{
|
22601
|
-
std::vector<
|
22916
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
|
22602
22917
|
res4 = swig::asptr(argv[2], &ptr);
|
22603
22918
|
if (!SWIG_IsOK(res4)) {
|
22604
|
-
SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::vector<
|
22919
|
+
SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &","__setitem__", 4, argv[2] ));
|
22605
22920
|
}
|
22606
22921
|
if (!ptr) {
|
22607
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector<
|
22922
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &","__setitem__", 4, argv[2]));
|
22608
22923
|
}
|
22609
22924
|
arg4 = ptr;
|
22610
22925
|
}
|
22611
22926
|
{
|
22612
22927
|
try {
|
22613
22928
|
try {
|
22614
|
-
result = (VALUE)
|
22929
|
+
result = (VALUE)std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2,arg3,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg4);
|
22930
|
+
}
|
22931
|
+
catch(std::invalid_argument &_e) {
|
22932
|
+
SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
|
22933
|
+
}
|
22934
|
+
}
|
22935
|
+
catch(string str) {
|
22936
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
22937
|
+
}
|
22938
|
+
catch(...) {
|
22939
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
22940
|
+
}
|
22941
|
+
}
|
22942
|
+
vresult = result;
|
22943
|
+
if (SWIG_IsNewObj(res4)) delete arg4;
|
22944
|
+
return vresult;
|
22945
|
+
fail:
|
22946
|
+
if (SWIG_IsNewObj(res4)) delete arg4;
|
22947
|
+
return Qnil;
|
22948
|
+
}
|
22949
|
+
|
22950
|
+
|
22951
|
+
SWIGINTERN VALUE _wrap_DoubleVector2d___setitem__(int nargs, VALUE *args, VALUE self) {
|
22952
|
+
int argc;
|
22953
|
+
VALUE argv[5];
|
22954
|
+
int ii;
|
22955
|
+
|
22956
|
+
argc = nargs + 1;
|
22957
|
+
argv[0] = self;
|
22958
|
+
if (argc > 5) SWIG_fail;
|
22959
|
+
for (ii = 1; (ii < argc); ++ii) {
|
22960
|
+
argv[ii] = args[ii-1];
|
22961
|
+
}
|
22962
|
+
if (argc == 3) {
|
22963
|
+
int _v;
|
22964
|
+
int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
|
22965
|
+
_v = SWIG_CheckState(res);
|
22966
|
+
if (_v) {
|
22967
|
+
{
|
22968
|
+
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
|
22969
|
+
_v = SWIG_CheckState(res);
|
22970
|
+
}
|
22971
|
+
if (_v) {
|
22972
|
+
int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
|
22973
|
+
_v = SWIG_CheckState(res);
|
22974
|
+
if (_v) {
|
22975
|
+
return _wrap_DoubleVector2d___setitem____SWIG_0(nargs, args, self);
|
22976
|
+
}
|
22977
|
+
}
|
22978
|
+
}
|
22979
|
+
}
|
22980
|
+
if (argc == 4) {
|
22981
|
+
int _v;
|
22982
|
+
int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
|
22983
|
+
_v = SWIG_CheckState(res);
|
22984
|
+
if (_v) {
|
22985
|
+
{
|
22986
|
+
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
|
22987
|
+
_v = SWIG_CheckState(res);
|
22988
|
+
}
|
22989
|
+
if (_v) {
|
22990
|
+
{
|
22991
|
+
int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
|
22992
|
+
_v = SWIG_CheckState(res);
|
22993
|
+
}
|
22994
|
+
if (_v) {
|
22995
|
+
int res = swig::asptr(argv[3], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
|
22996
|
+
_v = SWIG_CheckState(res);
|
22997
|
+
if (_v) {
|
22998
|
+
return _wrap_DoubleVector2d___setitem____SWIG_1(nargs, args, self);
|
22999
|
+
}
|
23000
|
+
}
|
23001
|
+
}
|
23002
|
+
}
|
23003
|
+
}
|
23004
|
+
|
23005
|
+
fail:
|
23006
|
+
Ruby_Format_OverloadedError( argc, 5, "__setitem__",
|
23007
|
+
" VALUE __setitem__(std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::value_type const &x)\n"
|
23008
|
+
" VALUE __setitem__(std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v)\n");
|
23009
|
+
|
23010
|
+
return Qnil;
|
23011
|
+
}
|
23012
|
+
|
23013
|
+
|
23014
|
+
|
23015
|
+
/*
|
23016
|
+
Document-method: Genmodel::DoubleVector2d.shift
|
23017
|
+
|
23018
|
+
call-seq:
|
23019
|
+
shift -> VALUE
|
23020
|
+
|
23021
|
+
Remove and return element at the beginning of the DoubleVector2d.
|
23022
|
+
*/
|
23023
|
+
SWIGINTERN VALUE
|
23024
|
+
_wrap_DoubleVector2d_shift(int argc, VALUE *argv, VALUE self) {
|
23025
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23026
|
+
void *argp1 = 0 ;
|
23027
|
+
int res1 = 0 ;
|
23028
|
+
VALUE result;
|
23029
|
+
VALUE vresult = Qnil;
|
23030
|
+
|
23031
|
+
if ((argc < 0) || (argc > 0)) {
|
23032
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
23033
|
+
}
|
23034
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23035
|
+
if (!SWIG_IsOK(res1)) {
|
23036
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","shift", 1, self ));
|
23037
|
+
}
|
23038
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23039
|
+
{
|
23040
|
+
try {
|
23041
|
+
result = (VALUE)std_vector_Sl_std_vector_Sl_double_Sg__Sg__shift(arg1);
|
23042
|
+
}
|
23043
|
+
catch(string str) {
|
23044
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23045
|
+
}
|
23046
|
+
catch(...) {
|
23047
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23048
|
+
}
|
23049
|
+
}
|
23050
|
+
vresult = result;
|
23051
|
+
return vresult;
|
23052
|
+
fail:
|
23053
|
+
return Qnil;
|
23054
|
+
}
|
23055
|
+
|
23056
|
+
|
23057
|
+
|
23058
|
+
/*
|
23059
|
+
Document-method: Genmodel::DoubleVector2d.insert
|
23060
|
+
|
23061
|
+
call-seq:
|
23062
|
+
insert(pos, argc) -> DoubleVector2d
|
23063
|
+
insert(pos, x) -> std::vector< std::vector< double > >::iterator
|
23064
|
+
insert(pos, n, x)
|
23065
|
+
|
23066
|
+
Insert one or more new elements in the DoubleVector2d.
|
23067
|
+
*/
|
23068
|
+
SWIGINTERN VALUE
|
23069
|
+
_wrap_DoubleVector2d_insert__SWIG_0(int argc, VALUE *argv, VALUE self) {
|
23070
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23071
|
+
std::vector< std::vector< double > >::difference_type arg2 ;
|
23072
|
+
int arg3 ;
|
23073
|
+
VALUE *arg4 = (VALUE *) 0 ;
|
23074
|
+
void *arg5 = 0 ;
|
23075
|
+
void *argp1 = 0 ;
|
23076
|
+
int res1 = 0 ;
|
23077
|
+
ptrdiff_t val2 ;
|
23078
|
+
int ecode2 = 0 ;
|
23079
|
+
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
|
23080
|
+
VALUE vresult = Qnil;
|
23081
|
+
|
23082
|
+
if (argc < 2) {
|
23083
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
23084
|
+
}
|
23085
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23086
|
+
if (!SWIG_IsOK(res1)) {
|
23087
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","insert", 1, self ));
|
23088
|
+
}
|
23089
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23090
|
+
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
23091
|
+
if (!SWIG_IsOK(ecode2)) {
|
23092
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::difference_type","insert", 2, argv[0] ));
|
23093
|
+
}
|
23094
|
+
arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
|
23095
|
+
{
|
23096
|
+
arg3 = argc - 1;
|
23097
|
+
arg4 = argv + 1;
|
23098
|
+
}
|
23099
|
+
{
|
23100
|
+
try {
|
23101
|
+
result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_0(arg1,arg2,arg3,arg4,arg5);
|
23102
|
+
}
|
23103
|
+
catch(string str) {
|
23104
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23105
|
+
}
|
23106
|
+
catch(...) {
|
23107
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23108
|
+
}
|
23109
|
+
}
|
23110
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23111
|
+
return vresult;
|
23112
|
+
fail:
|
23113
|
+
return Qnil;
|
23114
|
+
}
|
23115
|
+
|
23116
|
+
|
23117
|
+
|
23118
|
+
/*
|
23119
|
+
Document-method: Genmodel::DoubleVector2d.unshift
|
23120
|
+
|
23121
|
+
call-seq:
|
23122
|
+
unshift(argc) -> DoubleVector2d
|
23123
|
+
|
23124
|
+
Add one or more elements at the beginning of the DoubleVector2d.
|
23125
|
+
*/
|
23126
|
+
SWIGINTERN VALUE
|
23127
|
+
_wrap_DoubleVector2d_unshift(int argc, VALUE *argv, VALUE self) {
|
23128
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23129
|
+
int arg2 ;
|
23130
|
+
VALUE *arg3 = (VALUE *) 0 ;
|
23131
|
+
void *arg4 = 0 ;
|
23132
|
+
void *argp1 = 0 ;
|
23133
|
+
int res1 = 0 ;
|
23134
|
+
std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
|
23135
|
+
VALUE vresult = Qnil;
|
23136
|
+
|
23137
|
+
if (argc < 1) {
|
23138
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
23139
|
+
}
|
23140
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23141
|
+
if (!SWIG_IsOK(res1)) {
|
23142
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","unshift", 1, self ));
|
23143
|
+
}
|
23144
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23145
|
+
{
|
23146
|
+
arg2 = argc;
|
23147
|
+
arg3 = argv;
|
23148
|
+
}
|
23149
|
+
{
|
23150
|
+
try {
|
23151
|
+
result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg__unshift(arg1,arg2,arg3,arg4);
|
23152
|
+
}
|
23153
|
+
catch(string str) {
|
23154
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23155
|
+
}
|
23156
|
+
catch(...) {
|
23157
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23158
|
+
}
|
23159
|
+
}
|
23160
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23161
|
+
return vresult;
|
23162
|
+
fail:
|
23163
|
+
return Qnil;
|
23164
|
+
}
|
23165
|
+
|
23166
|
+
|
23167
|
+
SWIGINTERN VALUE
|
23168
|
+
_wrap_new_DoubleVector2d__SWIG_0(int argc, VALUE *argv, VALUE self) {
|
23169
|
+
std::vector< std::vector< double > > *result = 0 ;
|
23170
|
+
|
23171
|
+
if ((argc < 0) || (argc > 0)) {
|
23172
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
23173
|
+
}
|
23174
|
+
{
|
23175
|
+
try {
|
23176
|
+
result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >();
|
23177
|
+
DATA_PTR(self) = result;
|
23178
|
+
}
|
23179
|
+
catch(string str) {
|
23180
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23181
|
+
}
|
23182
|
+
catch(...) {
|
23183
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23184
|
+
}
|
23185
|
+
}
|
23186
|
+
return self;
|
23187
|
+
fail:
|
23188
|
+
return Qnil;
|
23189
|
+
}
|
23190
|
+
|
23191
|
+
|
23192
|
+
SWIGINTERN VALUE
|
23193
|
+
_wrap_new_DoubleVector2d__SWIG_1(int argc, VALUE *argv, VALUE self) {
|
23194
|
+
std::vector< std::vector< double,std::allocator< double > > > *arg1 = 0 ;
|
23195
|
+
int res1 = SWIG_OLDOBJ ;
|
23196
|
+
std::vector< std::vector< double > > *result = 0 ;
|
23197
|
+
|
23198
|
+
if ((argc < 1) || (argc > 1)) {
|
23199
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
23200
|
+
}
|
23201
|
+
{
|
23202
|
+
std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
|
23203
|
+
res1 = swig::asptr(argv[0], &ptr);
|
23204
|
+
if (!SWIG_IsOK(res1)) {
|
23205
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double,std::allocator< double > > > const &","vector<(std::vector<(double)>)>", 1, argv[0] ));
|
23206
|
+
}
|
23207
|
+
if (!ptr) {
|
23208
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::vector< double,std::allocator< double > > > const &","vector<(std::vector<(double)>)>", 1, argv[0]));
|
23209
|
+
}
|
23210
|
+
arg1 = ptr;
|
23211
|
+
}
|
23212
|
+
{
|
23213
|
+
try {
|
23214
|
+
result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >((std::vector< std::vector< double,std::allocator< double > > > const &)*arg1);
|
23215
|
+
DATA_PTR(self) = result;
|
23216
|
+
}
|
23217
|
+
catch(string str) {
|
23218
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23219
|
+
}
|
23220
|
+
catch(...) {
|
23221
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23222
|
+
}
|
23223
|
+
}
|
23224
|
+
if (SWIG_IsNewObj(res1)) delete arg1;
|
23225
|
+
return self;
|
23226
|
+
fail:
|
23227
|
+
if (SWIG_IsNewObj(res1)) delete arg1;
|
23228
|
+
return Qnil;
|
23229
|
+
}
|
23230
|
+
|
23231
|
+
|
23232
|
+
|
23233
|
+
/*
|
23234
|
+
Document-method: Genmodel::DoubleVector2d.empty?
|
23235
|
+
|
23236
|
+
call-seq:
|
23237
|
+
empty? -> bool
|
23238
|
+
|
23239
|
+
Check if the DoubleVector2d is empty or not.
|
23240
|
+
*/
|
23241
|
+
SWIGINTERN VALUE
|
23242
|
+
_wrap_DoubleVector2d_emptyq___(int argc, VALUE *argv, VALUE self) {
|
23243
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23244
|
+
void *argp1 = 0 ;
|
23245
|
+
int res1 = 0 ;
|
23246
|
+
bool result;
|
23247
|
+
VALUE vresult = Qnil;
|
23248
|
+
|
23249
|
+
if ((argc < 0) || (argc > 0)) {
|
23250
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
23251
|
+
}
|
23252
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23253
|
+
if (!SWIG_IsOK(res1)) {
|
23254
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > const *","empty", 1, self ));
|
23255
|
+
}
|
23256
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23257
|
+
{
|
23258
|
+
try {
|
23259
|
+
result = (bool)((std::vector< std::vector< double > > const *)arg1)->empty();
|
23260
|
+
}
|
23261
|
+
catch(string str) {
|
23262
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23263
|
+
}
|
23264
|
+
catch(...) {
|
23265
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23266
|
+
}
|
23267
|
+
}
|
23268
|
+
vresult = SWIG_From_bool(static_cast< bool >(result));
|
23269
|
+
return vresult;
|
23270
|
+
fail:
|
23271
|
+
return Qnil;
|
23272
|
+
}
|
23273
|
+
|
23274
|
+
|
23275
|
+
|
23276
|
+
/*
|
23277
|
+
Document-method: Genmodel::DoubleVector2d.size
|
23278
|
+
|
23279
|
+
call-seq:
|
23280
|
+
size -> std::vector< std::vector< double > >::size_type
|
23281
|
+
|
23282
|
+
Size or Length of the DoubleVector2d.
|
23283
|
+
*/
|
23284
|
+
SWIGINTERN VALUE
|
23285
|
+
_wrap_DoubleVector2d_size(int argc, VALUE *argv, VALUE self) {
|
23286
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23287
|
+
void *argp1 = 0 ;
|
23288
|
+
int res1 = 0 ;
|
23289
|
+
std::vector< std::vector< double > >::size_type result;
|
23290
|
+
VALUE vresult = Qnil;
|
23291
|
+
|
23292
|
+
if ((argc < 0) || (argc > 0)) {
|
23293
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
23294
|
+
}
|
23295
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23296
|
+
if (!SWIG_IsOK(res1)) {
|
23297
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > const *","size", 1, self ));
|
23298
|
+
}
|
23299
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23300
|
+
{
|
23301
|
+
try {
|
23302
|
+
result = ((std::vector< std::vector< double > > const *)arg1)->size();
|
23303
|
+
}
|
23304
|
+
catch(string str) {
|
23305
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23306
|
+
}
|
23307
|
+
catch(...) {
|
23308
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23309
|
+
}
|
23310
|
+
}
|
23311
|
+
vresult = SWIG_From_size_t(static_cast< size_t >(result));
|
23312
|
+
return vresult;
|
23313
|
+
fail:
|
23314
|
+
return Qnil;
|
23315
|
+
}
|
23316
|
+
|
23317
|
+
|
23318
|
+
|
23319
|
+
/*
|
23320
|
+
Document-method: Genmodel::DoubleVector2d.clear
|
23321
|
+
|
23322
|
+
call-seq:
|
23323
|
+
clear
|
23324
|
+
|
23325
|
+
Clear DoubleVector2d contents.
|
23326
|
+
*/
|
23327
|
+
SWIGINTERN VALUE
|
23328
|
+
_wrap_DoubleVector2d_clear(int argc, VALUE *argv, VALUE self) {
|
23329
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23330
|
+
void *argp1 = 0 ;
|
23331
|
+
int res1 = 0 ;
|
23332
|
+
|
23333
|
+
if ((argc < 0) || (argc > 0)) {
|
23334
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
23335
|
+
}
|
23336
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23337
|
+
if (!SWIG_IsOK(res1)) {
|
23338
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","clear", 1, self ));
|
23339
|
+
}
|
23340
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23341
|
+
{
|
23342
|
+
try {
|
23343
|
+
(arg1)->clear();
|
23344
|
+
}
|
23345
|
+
catch(string str) {
|
23346
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23347
|
+
}
|
23348
|
+
catch(...) {
|
23349
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23350
|
+
}
|
23351
|
+
}
|
23352
|
+
return Qnil;
|
23353
|
+
fail:
|
23354
|
+
return Qnil;
|
23355
|
+
}
|
23356
|
+
|
23357
|
+
|
23358
|
+
SWIGINTERN VALUE
|
23359
|
+
_wrap_DoubleVector2d_swap(int argc, VALUE *argv, VALUE self) {
|
23360
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23361
|
+
std::vector< std::vector< double,std::allocator< double > > > *arg2 = 0 ;
|
23362
|
+
void *argp1 = 0 ;
|
23363
|
+
int res1 = 0 ;
|
23364
|
+
void *argp2 = 0 ;
|
23365
|
+
int res2 = 0 ;
|
23366
|
+
|
23367
|
+
if ((argc < 1) || (argc > 1)) {
|
23368
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
23369
|
+
}
|
23370
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23371
|
+
if (!SWIG_IsOK(res1)) {
|
23372
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","swap", 1, self ));
|
23373
|
+
}
|
23374
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23375
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 );
|
23376
|
+
if (!SWIG_IsOK(res2)) {
|
23377
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::vector< double,std::allocator< double > > > &","swap", 2, argv[0] ));
|
23378
|
+
}
|
23379
|
+
if (!argp2) {
|
23380
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::vector< double,std::allocator< double > > > &","swap", 2, argv[0]));
|
23381
|
+
}
|
23382
|
+
arg2 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
|
23383
|
+
{
|
23384
|
+
try {
|
23385
|
+
(arg1)->swap(*arg2);
|
23386
|
+
}
|
23387
|
+
catch(string str) {
|
23388
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23389
|
+
}
|
23390
|
+
catch(...) {
|
23391
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23392
|
+
}
|
23393
|
+
}
|
23394
|
+
return Qnil;
|
23395
|
+
fail:
|
23396
|
+
return Qnil;
|
23397
|
+
}
|
23398
|
+
|
23399
|
+
|
23400
|
+
SWIGINTERN VALUE
|
23401
|
+
_wrap_DoubleVector2d_get_allocator(int argc, VALUE *argv, VALUE self) {
|
23402
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23403
|
+
void *argp1 = 0 ;
|
23404
|
+
int res1 = 0 ;
|
23405
|
+
SwigValueWrapper< std::allocator< std::vector< double,std::allocator< double > > > > result;
|
23406
|
+
VALUE vresult = Qnil;
|
23407
|
+
|
23408
|
+
if ((argc < 0) || (argc > 0)) {
|
23409
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
23410
|
+
}
|
23411
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23412
|
+
if (!SWIG_IsOK(res1)) {
|
23413
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > const *","get_allocator", 1, self ));
|
23414
|
+
}
|
23415
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23416
|
+
{
|
23417
|
+
try {
|
23418
|
+
result = ((std::vector< std::vector< double > > const *)arg1)->get_allocator();
|
23419
|
+
}
|
23420
|
+
catch(string str) {
|
23421
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23422
|
+
}
|
23423
|
+
catch(...) {
|
23424
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23425
|
+
}
|
23426
|
+
}
|
23427
|
+
vresult = SWIG_NewPointerObj((new std::vector< std::vector< double > >::allocator_type(static_cast< const std::vector< std::vector< double > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t, SWIG_POINTER_OWN | 0 );
|
23428
|
+
return vresult;
|
23429
|
+
fail:
|
23430
|
+
return Qnil;
|
23431
|
+
}
|
23432
|
+
|
23433
|
+
|
23434
|
+
|
23435
|
+
/*
|
23436
|
+
Document-method: Genmodel::DoubleVector2d.begin
|
23437
|
+
|
23438
|
+
call-seq:
|
23439
|
+
begin -> std::vector< std::vector< double > >::iterator
|
23440
|
+
|
23441
|
+
Return an iterator to the beginning of the DoubleVector2d.
|
23442
|
+
*/
|
23443
|
+
SWIGINTERN VALUE
|
23444
|
+
_wrap_DoubleVector2d_begin(int argc, VALUE *argv, VALUE self) {
|
23445
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23446
|
+
void *argp1 = 0 ;
|
23447
|
+
int res1 = 0 ;
|
23448
|
+
std::vector< std::vector< double > >::iterator result;
|
23449
|
+
VALUE vresult = Qnil;
|
23450
|
+
|
23451
|
+
if ((argc < 0) || (argc > 0)) {
|
23452
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
23453
|
+
}
|
23454
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23455
|
+
if (!SWIG_IsOK(res1)) {
|
23456
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","begin", 1, self ));
|
23457
|
+
}
|
23458
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23459
|
+
{
|
23460
|
+
try {
|
23461
|
+
result = (arg1)->begin();
|
23462
|
+
}
|
23463
|
+
catch(string str) {
|
23464
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23465
|
+
}
|
23466
|
+
catch(...) {
|
23467
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23468
|
+
}
|
23469
|
+
}
|
23470
|
+
vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result),
|
23471
|
+
self),
|
23472
|
+
swig::Iterator::descriptor(),SWIG_POINTER_OWN);
|
23473
|
+
return vresult;
|
23474
|
+
fail:
|
23475
|
+
return Qnil;
|
23476
|
+
}
|
23477
|
+
|
23478
|
+
|
23479
|
+
|
23480
|
+
/*
|
23481
|
+
Document-method: Genmodel::DoubleVector2d.end
|
23482
|
+
|
23483
|
+
call-seq:
|
23484
|
+
end -> std::vector< std::vector< double > >::iterator
|
23485
|
+
|
23486
|
+
Return an iterator to past the end of the DoubleVector2d.
|
23487
|
+
*/
|
23488
|
+
SWIGINTERN VALUE
|
23489
|
+
_wrap_DoubleVector2d_end(int argc, VALUE *argv, VALUE self) {
|
23490
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23491
|
+
void *argp1 = 0 ;
|
23492
|
+
int res1 = 0 ;
|
23493
|
+
std::vector< std::vector< double > >::iterator result;
|
23494
|
+
VALUE vresult = Qnil;
|
23495
|
+
|
23496
|
+
if ((argc < 0) || (argc > 0)) {
|
23497
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
23498
|
+
}
|
23499
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23500
|
+
if (!SWIG_IsOK(res1)) {
|
23501
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","end", 1, self ));
|
23502
|
+
}
|
23503
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23504
|
+
{
|
23505
|
+
try {
|
23506
|
+
result = (arg1)->end();
|
23507
|
+
}
|
23508
|
+
catch(string str) {
|
23509
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23510
|
+
}
|
23511
|
+
catch(...) {
|
23512
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23513
|
+
}
|
23514
|
+
}
|
23515
|
+
vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result),
|
23516
|
+
self),
|
23517
|
+
swig::Iterator::descriptor(),SWIG_POINTER_OWN);
|
23518
|
+
return vresult;
|
23519
|
+
fail:
|
23520
|
+
return Qnil;
|
23521
|
+
}
|
23522
|
+
|
23523
|
+
|
23524
|
+
|
23525
|
+
/*
|
23526
|
+
Document-method: Genmodel::DoubleVector2d.rbegin
|
23527
|
+
|
23528
|
+
call-seq:
|
23529
|
+
rbegin -> std::vector< std::vector< double > >::reverse_iterator
|
23530
|
+
|
23531
|
+
Return a reverse iterator to the beginning (the end) of the DoubleVector2d.
|
23532
|
+
*/
|
23533
|
+
SWIGINTERN VALUE
|
23534
|
+
_wrap_DoubleVector2d_rbegin(int argc, VALUE *argv, VALUE self) {
|
23535
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23536
|
+
void *argp1 = 0 ;
|
23537
|
+
int res1 = 0 ;
|
23538
|
+
std::vector< std::vector< double > >::reverse_iterator result;
|
23539
|
+
VALUE vresult = Qnil;
|
23540
|
+
|
23541
|
+
if ((argc < 0) || (argc > 0)) {
|
23542
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
23543
|
+
}
|
23544
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23545
|
+
if (!SWIG_IsOK(res1)) {
|
23546
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","rbegin", 1, self ));
|
23547
|
+
}
|
23548
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23549
|
+
{
|
23550
|
+
try {
|
23551
|
+
result = (arg1)->rbegin();
|
23552
|
+
}
|
23553
|
+
catch(string str) {
|
23554
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23555
|
+
}
|
23556
|
+
catch(...) {
|
23557
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23558
|
+
}
|
23559
|
+
}
|
23560
|
+
vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< std::vector< double > >::reverse_iterator & >(result),
|
23561
|
+
self),
|
23562
|
+
swig::Iterator::descriptor(),SWIG_POINTER_OWN);
|
23563
|
+
return vresult;
|
23564
|
+
fail:
|
23565
|
+
return Qnil;
|
23566
|
+
}
|
23567
|
+
|
23568
|
+
|
23569
|
+
|
23570
|
+
/*
|
23571
|
+
Document-method: Genmodel::DoubleVector2d.rend
|
23572
|
+
|
23573
|
+
call-seq:
|
23574
|
+
rend -> std::vector< std::vector< double > >::reverse_iterator
|
23575
|
+
|
23576
|
+
Return a reverse iterator to past the end (past the beginning) of the DoubleVector2d.
|
23577
|
+
*/
|
23578
|
+
SWIGINTERN VALUE
|
23579
|
+
_wrap_DoubleVector2d_rend(int argc, VALUE *argv, VALUE self) {
|
23580
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23581
|
+
void *argp1 = 0 ;
|
23582
|
+
int res1 = 0 ;
|
23583
|
+
std::vector< std::vector< double > >::reverse_iterator result;
|
23584
|
+
VALUE vresult = Qnil;
|
23585
|
+
|
23586
|
+
if ((argc < 0) || (argc > 0)) {
|
23587
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
23588
|
+
}
|
23589
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23590
|
+
if (!SWIG_IsOK(res1)) {
|
23591
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","rend", 1, self ));
|
23592
|
+
}
|
23593
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23594
|
+
{
|
23595
|
+
try {
|
23596
|
+
result = (arg1)->rend();
|
23597
|
+
}
|
23598
|
+
catch(string str) {
|
23599
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23600
|
+
}
|
23601
|
+
catch(...) {
|
23602
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23603
|
+
}
|
23604
|
+
}
|
23605
|
+
vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< std::vector< double > >::reverse_iterator & >(result),
|
23606
|
+
self),
|
23607
|
+
swig::Iterator::descriptor(),SWIG_POINTER_OWN);
|
23608
|
+
return vresult;
|
23609
|
+
fail:
|
23610
|
+
return Qnil;
|
23611
|
+
}
|
23612
|
+
|
23613
|
+
|
23614
|
+
SWIGINTERN VALUE
|
23615
|
+
_wrap_new_DoubleVector2d__SWIG_2(int argc, VALUE *argv, VALUE self) {
|
23616
|
+
std::vector< std::vector< double > >::size_type arg1 ;
|
23617
|
+
size_t val1 ;
|
23618
|
+
int ecode1 = 0 ;
|
23619
|
+
std::vector< std::vector< double > > *result = 0 ;
|
23620
|
+
|
23621
|
+
if ((argc < 1) || (argc > 1)) {
|
23622
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
23623
|
+
}
|
23624
|
+
ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
|
23625
|
+
if (!SWIG_IsOK(ecode1)) {
|
23626
|
+
SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::size_type","vector<(std::vector<(double)>)>", 1, argv[0] ));
|
23627
|
+
}
|
23628
|
+
arg1 = static_cast< std::vector< std::vector< double > >::size_type >(val1);
|
23629
|
+
{
|
23630
|
+
try {
|
23631
|
+
result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >(arg1);
|
23632
|
+
DATA_PTR(self) = result;
|
23633
|
+
}
|
23634
|
+
catch(string str) {
|
23635
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23636
|
+
}
|
23637
|
+
catch(...) {
|
23638
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23639
|
+
}
|
23640
|
+
}
|
23641
|
+
return self;
|
23642
|
+
fail:
|
23643
|
+
return Qnil;
|
23644
|
+
}
|
23645
|
+
|
23646
|
+
|
23647
|
+
|
23648
|
+
/*
|
23649
|
+
Document-method: Genmodel::DoubleVector2d.resize
|
23650
|
+
|
23651
|
+
call-seq:
|
23652
|
+
resize(new_size)
|
23653
|
+
resize(new_size, x)
|
23654
|
+
|
23655
|
+
Resize the size of the DoubleVector2d.
|
23656
|
+
*/
|
23657
|
+
SWIGINTERN VALUE
|
23658
|
+
_wrap_DoubleVector2d_resize__SWIG_0(int argc, VALUE *argv, VALUE self) {
|
23659
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23660
|
+
std::vector< std::vector< double > >::size_type arg2 ;
|
23661
|
+
void *argp1 = 0 ;
|
23662
|
+
int res1 = 0 ;
|
23663
|
+
size_t val2 ;
|
23664
|
+
int ecode2 = 0 ;
|
23665
|
+
|
23666
|
+
if ((argc < 1) || (argc > 1)) {
|
23667
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
23668
|
+
}
|
23669
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23670
|
+
if (!SWIG_IsOK(res1)) {
|
23671
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","resize", 1, self ));
|
23672
|
+
}
|
23673
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23674
|
+
ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
|
23675
|
+
if (!SWIG_IsOK(ecode2)) {
|
23676
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::size_type","resize", 2, argv[0] ));
|
23677
|
+
}
|
23678
|
+
arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
|
23679
|
+
{
|
23680
|
+
try {
|
23681
|
+
(arg1)->resize(arg2);
|
23682
|
+
}
|
23683
|
+
catch(string str) {
|
23684
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23685
|
+
}
|
23686
|
+
catch(...) {
|
23687
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23688
|
+
}
|
23689
|
+
}
|
23690
|
+
return Qnil;
|
23691
|
+
fail:
|
23692
|
+
return Qnil;
|
23693
|
+
}
|
23694
|
+
|
23695
|
+
|
23696
|
+
|
23697
|
+
/*
|
23698
|
+
Document-method: Genmodel::DoubleVector2d.erase
|
23699
|
+
|
23700
|
+
call-seq:
|
23701
|
+
erase(pos) -> std::vector< std::vector< double > >::iterator
|
23702
|
+
erase(first, last) -> std::vector< std::vector< double > >::iterator
|
23703
|
+
|
23704
|
+
Delete a portion of the DoubleVector2d.
|
23705
|
+
*/
|
23706
|
+
SWIGINTERN VALUE
|
23707
|
+
_wrap_DoubleVector2d_erase__SWIG_0(int argc, VALUE *argv, VALUE self) {
|
23708
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23709
|
+
std::vector< std::vector< double > >::iterator arg2 ;
|
23710
|
+
void *argp1 = 0 ;
|
23711
|
+
int res1 = 0 ;
|
23712
|
+
swig::Iterator *iter2 = 0 ;
|
23713
|
+
int res2 ;
|
23714
|
+
std::vector< std::vector< double > >::iterator result;
|
23715
|
+
VALUE vresult = Qnil;
|
23716
|
+
|
23717
|
+
if ((argc < 1) || (argc > 1)) {
|
23718
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
23719
|
+
}
|
23720
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23721
|
+
if (!SWIG_IsOK(res1)) {
|
23722
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","erase", 1, self ));
|
23723
|
+
}
|
23724
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23725
|
+
res2 = SWIG_ConvertPtr(argv[0], SWIG_as_voidptrptr(&iter2), swig::Iterator::descriptor(), 0);
|
23726
|
+
if (!SWIG_IsOK(res2) || !iter2) {
|
23727
|
+
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::iterator","erase", 2, argv[0] ));
|
23728
|
+
} else {
|
23729
|
+
swig::Iterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::Iterator_T<std::vector< std::vector< double > >::iterator > *>(iter2);
|
23730
|
+
if (iter_t) {
|
23731
|
+
arg2 = iter_t->get_current();
|
23732
|
+
} else {
|
23733
|
+
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::iterator","erase", 2, argv[0] ));
|
23734
|
+
}
|
23735
|
+
}
|
23736
|
+
{
|
23737
|
+
try {
|
23738
|
+
result = (arg1)->erase(arg2);
|
23739
|
+
}
|
23740
|
+
catch(string str) {
|
23741
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23742
|
+
}
|
23743
|
+
catch(...) {
|
23744
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23745
|
+
}
|
23746
|
+
}
|
23747
|
+
vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result),
|
23748
|
+
self),
|
23749
|
+
swig::Iterator::descriptor(),SWIG_POINTER_OWN);
|
23750
|
+
return vresult;
|
23751
|
+
fail:
|
23752
|
+
return Qnil;
|
23753
|
+
}
|
23754
|
+
|
23755
|
+
|
23756
|
+
SWIGINTERN VALUE
|
23757
|
+
_wrap_DoubleVector2d_erase__SWIG_1(int argc, VALUE *argv, VALUE self) {
|
23758
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
23759
|
+
std::vector< std::vector< double > >::iterator arg2 ;
|
23760
|
+
std::vector< std::vector< double > >::iterator arg3 ;
|
23761
|
+
void *argp1 = 0 ;
|
23762
|
+
int res1 = 0 ;
|
23763
|
+
swig::Iterator *iter2 = 0 ;
|
23764
|
+
int res2 ;
|
23765
|
+
swig::Iterator *iter3 = 0 ;
|
23766
|
+
int res3 ;
|
23767
|
+
std::vector< std::vector< double > >::iterator result;
|
23768
|
+
VALUE vresult = Qnil;
|
23769
|
+
|
23770
|
+
if ((argc < 2) || (argc > 2)) {
|
23771
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
23772
|
+
}
|
23773
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
23774
|
+
if (!SWIG_IsOK(res1)) {
|
23775
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","erase", 1, self ));
|
23776
|
+
}
|
23777
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
23778
|
+
res2 = SWIG_ConvertPtr(argv[0], SWIG_as_voidptrptr(&iter2), swig::Iterator::descriptor(), 0);
|
23779
|
+
if (!SWIG_IsOK(res2) || !iter2) {
|
23780
|
+
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::iterator","erase", 2, argv[0] ));
|
23781
|
+
} else {
|
23782
|
+
swig::Iterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::Iterator_T<std::vector< std::vector< double > >::iterator > *>(iter2);
|
23783
|
+
if (iter_t) {
|
23784
|
+
arg2 = iter_t->get_current();
|
23785
|
+
} else {
|
23786
|
+
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::iterator","erase", 2, argv[0] ));
|
23787
|
+
}
|
23788
|
+
}
|
23789
|
+
res3 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter3), swig::Iterator::descriptor(), 0);
|
23790
|
+
if (!SWIG_IsOK(res3) || !iter3) {
|
23791
|
+
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::iterator","erase", 3, argv[1] ));
|
23792
|
+
} else {
|
23793
|
+
swig::Iterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::Iterator_T<std::vector< std::vector< double > >::iterator > *>(iter3);
|
23794
|
+
if (iter_t) {
|
23795
|
+
arg3 = iter_t->get_current();
|
23796
|
+
} else {
|
23797
|
+
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::iterator","erase", 3, argv[1] ));
|
23798
|
+
}
|
23799
|
+
}
|
23800
|
+
{
|
23801
|
+
try {
|
23802
|
+
result = (arg1)->erase(arg2,arg3);
|
23803
|
+
}
|
23804
|
+
catch(string str) {
|
23805
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23806
|
+
}
|
23807
|
+
catch(...) {
|
23808
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23809
|
+
}
|
23810
|
+
}
|
23811
|
+
vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result),
|
23812
|
+
self),
|
23813
|
+
swig::Iterator::descriptor(),SWIG_POINTER_OWN);
|
23814
|
+
return vresult;
|
23815
|
+
fail:
|
23816
|
+
return Qnil;
|
23817
|
+
}
|
23818
|
+
|
23819
|
+
|
23820
|
+
SWIGINTERN VALUE _wrap_DoubleVector2d_erase(int nargs, VALUE *args, VALUE self) {
|
23821
|
+
int argc;
|
23822
|
+
VALUE argv[4];
|
23823
|
+
int ii;
|
23824
|
+
|
23825
|
+
argc = nargs + 1;
|
23826
|
+
argv[0] = self;
|
23827
|
+
if (argc > 4) SWIG_fail;
|
23828
|
+
for (ii = 1; (ii < argc); ++ii) {
|
23829
|
+
argv[ii] = args[ii-1];
|
23830
|
+
}
|
23831
|
+
if (argc == 2) {
|
23832
|
+
int _v;
|
23833
|
+
int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
|
23834
|
+
_v = SWIG_CheckState(res);
|
23835
|
+
if (_v) {
|
23836
|
+
swig::ConstIterator *iter = 0;
|
23837
|
+
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter),
|
23838
|
+
swig::Iterator::descriptor(), 0);
|
23839
|
+
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
|
23840
|
+
if (_v) {
|
23841
|
+
return _wrap_DoubleVector2d_erase__SWIG_0(nargs, args, self);
|
23842
|
+
}
|
23843
|
+
}
|
23844
|
+
}
|
23845
|
+
if (argc == 3) {
|
23846
|
+
int _v;
|
23847
|
+
int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
|
23848
|
+
_v = SWIG_CheckState(res);
|
23849
|
+
if (_v) {
|
23850
|
+
swig::ConstIterator *iter = 0;
|
23851
|
+
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter),
|
23852
|
+
swig::Iterator::descriptor(), 0);
|
23853
|
+
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
|
23854
|
+
if (_v) {
|
23855
|
+
swig::ConstIterator *iter = 0;
|
23856
|
+
int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter),
|
23857
|
+
swig::Iterator::descriptor(), 0);
|
23858
|
+
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
|
23859
|
+
if (_v) {
|
23860
|
+
return _wrap_DoubleVector2d_erase__SWIG_1(nargs, args, self);
|
23861
|
+
}
|
23862
|
+
}
|
23863
|
+
}
|
23864
|
+
}
|
23865
|
+
|
23866
|
+
fail:
|
23867
|
+
Ruby_Format_OverloadedError( argc, 4, "DoubleVector2d.erase",
|
23868
|
+
" std::vector< std::vector< double > >::iterator DoubleVector2d.erase(std::vector< std::vector< double > >::iterator pos)\n"
|
23869
|
+
" std::vector< std::vector< double > >::iterator DoubleVector2d.erase(std::vector< std::vector< double > >::iterator first, std::vector< std::vector< double > >::iterator last)\n");
|
23870
|
+
|
23871
|
+
return Qnil;
|
23872
|
+
}
|
23873
|
+
|
23874
|
+
|
23875
|
+
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
|
23876
|
+
SWIGINTERN VALUE
|
23877
|
+
_wrap_DoubleVector2d_allocate(VALUE self) {
|
23878
|
+
#else
|
23879
|
+
SWIGINTERN VALUE
|
23880
|
+
_wrap_DoubleVector2d_allocate(int argc, VALUE *argv, VALUE self) {
|
23881
|
+
#endif
|
23882
|
+
|
23883
|
+
|
23884
|
+
VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t);
|
23885
|
+
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
|
23886
|
+
rb_obj_call_init(vresult, argc, argv);
|
23887
|
+
#endif
|
23888
|
+
return vresult;
|
23889
|
+
}
|
23890
|
+
|
23891
|
+
|
23892
|
+
SWIGINTERN VALUE
|
23893
|
+
_wrap_new_DoubleVector2d__SWIG_3(int argc, VALUE *argv, VALUE self) {
|
23894
|
+
std::vector< std::vector< double > >::size_type arg1 ;
|
23895
|
+
std::vector< std::vector< double > >::value_type *arg2 = 0 ;
|
23896
|
+
size_t val1 ;
|
23897
|
+
int ecode1 = 0 ;
|
23898
|
+
int res2 = SWIG_OLDOBJ ;
|
23899
|
+
std::vector< std::vector< double > > *result = 0 ;
|
23900
|
+
|
23901
|
+
if ((argc < 2) || (argc > 2)) {
|
23902
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
23903
|
+
}
|
23904
|
+
ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
|
23905
|
+
if (!SWIG_IsOK(ecode1)) {
|
23906
|
+
SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::size_type","vector<(std::vector<(double)>)>", 1, argv[0] ));
|
23907
|
+
}
|
23908
|
+
arg1 = static_cast< std::vector< std::vector< double > >::size_type >(val1);
|
23909
|
+
{
|
23910
|
+
std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
|
23911
|
+
res2 = swig::asptr(argv[1], &ptr);
|
23912
|
+
if (!SWIG_IsOK(res2)) {
|
23913
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::value_type const &","vector<(std::vector<(double)>)>", 2, argv[1] ));
|
23914
|
+
}
|
23915
|
+
if (!ptr) {
|
23916
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::vector< double > >::value_type const &","vector<(std::vector<(double)>)>", 2, argv[1]));
|
23917
|
+
}
|
23918
|
+
arg2 = ptr;
|
23919
|
+
}
|
23920
|
+
{
|
23921
|
+
try {
|
23922
|
+
result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >(arg1,(std::vector< std::vector< double > >::value_type const &)*arg2);
|
23923
|
+
DATA_PTR(self) = result;
|
23924
|
+
}
|
23925
|
+
catch(string str) {
|
23926
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
23927
|
+
}
|
23928
|
+
catch(...) {
|
23929
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
23930
|
+
}
|
23931
|
+
}
|
23932
|
+
if (SWIG_IsNewObj(res2)) delete arg2;
|
23933
|
+
return self;
|
23934
|
+
fail:
|
23935
|
+
if (SWIG_IsNewObj(res2)) delete arg2;
|
23936
|
+
return Qnil;
|
23937
|
+
}
|
23938
|
+
|
23939
|
+
|
23940
|
+
SWIGINTERN VALUE _wrap_new_DoubleVector2d(int nargs, VALUE *args, VALUE self) {
|
23941
|
+
int argc;
|
23942
|
+
VALUE argv[2];
|
23943
|
+
int ii;
|
23944
|
+
|
23945
|
+
argc = nargs;
|
23946
|
+
if (argc > 2) SWIG_fail;
|
23947
|
+
for (ii = 0; (ii < argc); ++ii) {
|
23948
|
+
argv[ii] = args[ii];
|
23949
|
+
}
|
23950
|
+
if (argc == 0) {
|
23951
|
+
return _wrap_new_DoubleVector2d__SWIG_0(nargs, args, self);
|
23952
|
+
}
|
23953
|
+
if (argc == 1) {
|
23954
|
+
int _v;
|
23955
|
+
{
|
23956
|
+
int res = SWIG_AsVal_size_t(argv[0], NULL);
|
23957
|
+
_v = SWIG_CheckState(res);
|
23958
|
+
}
|
23959
|
+
if (_v) {
|
23960
|
+
return _wrap_new_DoubleVector2d__SWIG_2(nargs, args, self);
|
23961
|
+
}
|
23962
|
+
}
|
23963
|
+
if (argc == 1) {
|
23964
|
+
int _v;
|
23965
|
+
int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
|
23966
|
+
_v = SWIG_CheckState(res);
|
23967
|
+
if (_v) {
|
23968
|
+
return _wrap_new_DoubleVector2d__SWIG_1(nargs, args, self);
|
23969
|
+
}
|
23970
|
+
}
|
23971
|
+
if (argc == 2) {
|
23972
|
+
int _v;
|
23973
|
+
{
|
23974
|
+
int res = SWIG_AsVal_size_t(argv[0], NULL);
|
23975
|
+
_v = SWIG_CheckState(res);
|
23976
|
+
}
|
23977
|
+
if (_v) {
|
23978
|
+
int res = swig::asptr(argv[1], (std::vector<double,std::allocator< double > >**)(0));
|
23979
|
+
_v = SWIG_CheckState(res);
|
23980
|
+
if (_v) {
|
23981
|
+
return _wrap_new_DoubleVector2d__SWIG_3(nargs, args, self);
|
23982
|
+
}
|
23983
|
+
}
|
23984
|
+
}
|
23985
|
+
|
23986
|
+
fail:
|
23987
|
+
Ruby_Format_OverloadedError( argc, 2, "DoubleVector2d.new",
|
23988
|
+
" DoubleVector2d.new()\n"
|
23989
|
+
" DoubleVector2d.new(std::vector< std::vector< double,std::allocator< double > > > const &)\n"
|
23990
|
+
" DoubleVector2d.new(std::vector< std::vector< double > >::size_type size)\n"
|
23991
|
+
" DoubleVector2d.new(std::vector< std::vector< double > >::size_type size, std::vector< std::vector< double > >::value_type const &value)\n");
|
23992
|
+
|
23993
|
+
return Qnil;
|
23994
|
+
}
|
23995
|
+
|
23996
|
+
|
23997
|
+
|
23998
|
+
/*
|
23999
|
+
Document-method: Genmodel::DoubleVector2d.front
|
24000
|
+
|
24001
|
+
call-seq:
|
24002
|
+
front -> DoubleVector
|
24003
|
+
|
24004
|
+
Return the first element in DoubleVector2d.
|
24005
|
+
*/
|
24006
|
+
SWIGINTERN VALUE
|
24007
|
+
_wrap_DoubleVector2d_front(int argc, VALUE *argv, VALUE self) {
|
24008
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
24009
|
+
void *argp1 = 0 ;
|
24010
|
+
int res1 = 0 ;
|
24011
|
+
std::vector< std::vector< double > >::value_type *result = 0 ;
|
24012
|
+
VALUE vresult = Qnil;
|
24013
|
+
|
24014
|
+
if ((argc < 0) || (argc > 0)) {
|
24015
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
24016
|
+
}
|
24017
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
24018
|
+
if (!SWIG_IsOK(res1)) {
|
24019
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > const *","front", 1, self ));
|
24020
|
+
}
|
24021
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
24022
|
+
{
|
24023
|
+
try {
|
24024
|
+
result = (std::vector< std::vector< double > >::value_type *) &((std::vector< std::vector< double > > const *)arg1)->front();
|
24025
|
+
}
|
24026
|
+
catch(string str) {
|
24027
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24028
|
+
}
|
24029
|
+
catch(...) {
|
24030
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24031
|
+
}
|
24032
|
+
}
|
24033
|
+
vresult = swig::from(static_cast< std::vector<double,std::allocator< double > > >(*result));
|
24034
|
+
return vresult;
|
24035
|
+
fail:
|
24036
|
+
return Qnil;
|
24037
|
+
}
|
24038
|
+
|
24039
|
+
|
24040
|
+
|
24041
|
+
/*
|
24042
|
+
Document-method: Genmodel::DoubleVector2d.back
|
24043
|
+
|
24044
|
+
call-seq:
|
24045
|
+
back -> DoubleVector
|
24046
|
+
|
24047
|
+
Return the last element in DoubleVector2d.
|
24048
|
+
*/
|
24049
|
+
SWIGINTERN VALUE
|
24050
|
+
_wrap_DoubleVector2d_back(int argc, VALUE *argv, VALUE self) {
|
24051
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
24052
|
+
void *argp1 = 0 ;
|
24053
|
+
int res1 = 0 ;
|
24054
|
+
std::vector< std::vector< double > >::value_type *result = 0 ;
|
24055
|
+
VALUE vresult = Qnil;
|
24056
|
+
|
24057
|
+
if ((argc < 0) || (argc > 0)) {
|
24058
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
24059
|
+
}
|
24060
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
24061
|
+
if (!SWIG_IsOK(res1)) {
|
24062
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > const *","back", 1, self ));
|
24063
|
+
}
|
24064
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
24065
|
+
{
|
24066
|
+
try {
|
24067
|
+
result = (std::vector< std::vector< double > >::value_type *) &((std::vector< std::vector< double > > const *)arg1)->back();
|
24068
|
+
}
|
24069
|
+
catch(string str) {
|
24070
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24071
|
+
}
|
24072
|
+
catch(...) {
|
24073
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24074
|
+
}
|
24075
|
+
}
|
24076
|
+
vresult = swig::from(static_cast< std::vector<double,std::allocator< double > > >(*result));
|
24077
|
+
return vresult;
|
24078
|
+
fail:
|
24079
|
+
return Qnil;
|
24080
|
+
}
|
24081
|
+
|
24082
|
+
|
24083
|
+
|
24084
|
+
/*
|
24085
|
+
Document-method: Genmodel::DoubleVector2d.assign
|
24086
|
+
|
24087
|
+
call-seq:
|
24088
|
+
assign(n, x)
|
24089
|
+
|
24090
|
+
Assign a new DoubleVector2d or portion of it.
|
24091
|
+
*/
|
24092
|
+
SWIGINTERN VALUE
|
24093
|
+
_wrap_DoubleVector2d_assign(int argc, VALUE *argv, VALUE self) {
|
24094
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
24095
|
+
std::vector< std::vector< double > >::size_type arg2 ;
|
24096
|
+
std::vector< std::vector< double > >::value_type *arg3 = 0 ;
|
24097
|
+
void *argp1 = 0 ;
|
24098
|
+
int res1 = 0 ;
|
24099
|
+
size_t val2 ;
|
24100
|
+
int ecode2 = 0 ;
|
24101
|
+
int res3 = SWIG_OLDOBJ ;
|
24102
|
+
|
24103
|
+
if ((argc < 2) || (argc > 2)) {
|
24104
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
24105
|
+
}
|
24106
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
24107
|
+
if (!SWIG_IsOK(res1)) {
|
24108
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","assign", 1, self ));
|
24109
|
+
}
|
24110
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
24111
|
+
ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
|
24112
|
+
if (!SWIG_IsOK(ecode2)) {
|
24113
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::size_type","assign", 2, argv[0] ));
|
24114
|
+
}
|
24115
|
+
arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
|
24116
|
+
{
|
24117
|
+
std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
|
24118
|
+
res3 = swig::asptr(argv[1], &ptr);
|
24119
|
+
if (!SWIG_IsOK(res3)) {
|
24120
|
+
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::value_type const &","assign", 3, argv[1] ));
|
24121
|
+
}
|
24122
|
+
if (!ptr) {
|
24123
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::vector< double > >::value_type const &","assign", 3, argv[1]));
|
24124
|
+
}
|
24125
|
+
arg3 = ptr;
|
24126
|
+
}
|
24127
|
+
{
|
24128
|
+
try {
|
24129
|
+
(arg1)->assign(arg2,(std::vector< std::vector< double > >::value_type const &)*arg3);
|
24130
|
+
}
|
24131
|
+
catch(string str) {
|
24132
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24133
|
+
}
|
24134
|
+
catch(...) {
|
24135
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24136
|
+
}
|
24137
|
+
}
|
24138
|
+
if (SWIG_IsNewObj(res3)) delete arg3;
|
24139
|
+
return Qnil;
|
24140
|
+
fail:
|
24141
|
+
if (SWIG_IsNewObj(res3)) delete arg3;
|
24142
|
+
return Qnil;
|
24143
|
+
}
|
24144
|
+
|
24145
|
+
|
24146
|
+
|
24147
|
+
/*
|
24148
|
+
Document-method: Genmodel::DoubleVector2d.resize
|
24149
|
+
|
24150
|
+
call-seq:
|
24151
|
+
resize(new_size)
|
24152
|
+
resize(new_size, x)
|
24153
|
+
|
24154
|
+
Resize the size of the DoubleVector2d.
|
24155
|
+
*/
|
24156
|
+
SWIGINTERN VALUE
|
24157
|
+
_wrap_DoubleVector2d_resize__SWIG_1(int argc, VALUE *argv, VALUE self) {
|
24158
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
24159
|
+
std::vector< std::vector< double > >::size_type arg2 ;
|
24160
|
+
std::vector< std::vector< double > >::value_type *arg3 = 0 ;
|
24161
|
+
void *argp1 = 0 ;
|
24162
|
+
int res1 = 0 ;
|
24163
|
+
size_t val2 ;
|
24164
|
+
int ecode2 = 0 ;
|
24165
|
+
int res3 = SWIG_OLDOBJ ;
|
24166
|
+
|
24167
|
+
if ((argc < 2) || (argc > 2)) {
|
24168
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
24169
|
+
}
|
24170
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
24171
|
+
if (!SWIG_IsOK(res1)) {
|
24172
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","resize", 1, self ));
|
24173
|
+
}
|
24174
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
24175
|
+
ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
|
24176
|
+
if (!SWIG_IsOK(ecode2)) {
|
24177
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::size_type","resize", 2, argv[0] ));
|
24178
|
+
}
|
24179
|
+
arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
|
24180
|
+
{
|
24181
|
+
std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
|
24182
|
+
res3 = swig::asptr(argv[1], &ptr);
|
24183
|
+
if (!SWIG_IsOK(res3)) {
|
24184
|
+
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::value_type const &","resize", 3, argv[1] ));
|
24185
|
+
}
|
24186
|
+
if (!ptr) {
|
24187
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::vector< double > >::value_type const &","resize", 3, argv[1]));
|
24188
|
+
}
|
24189
|
+
arg3 = ptr;
|
24190
|
+
}
|
24191
|
+
{
|
24192
|
+
try {
|
24193
|
+
(arg1)->resize(arg2,(std::vector< std::vector< double > >::value_type const &)*arg3);
|
24194
|
+
}
|
24195
|
+
catch(string str) {
|
24196
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24197
|
+
}
|
24198
|
+
catch(...) {
|
24199
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24200
|
+
}
|
24201
|
+
}
|
24202
|
+
if (SWIG_IsNewObj(res3)) delete arg3;
|
24203
|
+
return Qnil;
|
24204
|
+
fail:
|
24205
|
+
if (SWIG_IsNewObj(res3)) delete arg3;
|
24206
|
+
return Qnil;
|
24207
|
+
}
|
24208
|
+
|
24209
|
+
|
24210
|
+
SWIGINTERN VALUE _wrap_DoubleVector2d_resize(int nargs, VALUE *args, VALUE self) {
|
24211
|
+
int argc;
|
24212
|
+
VALUE argv[4];
|
24213
|
+
int ii;
|
24214
|
+
|
24215
|
+
argc = nargs + 1;
|
24216
|
+
argv[0] = self;
|
24217
|
+
if (argc > 4) SWIG_fail;
|
24218
|
+
for (ii = 1; (ii < argc); ++ii) {
|
24219
|
+
argv[ii] = args[ii-1];
|
24220
|
+
}
|
24221
|
+
if (argc == 2) {
|
24222
|
+
int _v;
|
24223
|
+
int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
|
24224
|
+
_v = SWIG_CheckState(res);
|
24225
|
+
if (_v) {
|
24226
|
+
{
|
24227
|
+
int res = SWIG_AsVal_size_t(argv[1], NULL);
|
24228
|
+
_v = SWIG_CheckState(res);
|
24229
|
+
}
|
24230
|
+
if (_v) {
|
24231
|
+
return _wrap_DoubleVector2d_resize__SWIG_0(nargs, args, self);
|
24232
|
+
}
|
24233
|
+
}
|
24234
|
+
}
|
24235
|
+
if (argc == 3) {
|
24236
|
+
int _v;
|
24237
|
+
int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
|
24238
|
+
_v = SWIG_CheckState(res);
|
24239
|
+
if (_v) {
|
24240
|
+
{
|
24241
|
+
int res = SWIG_AsVal_size_t(argv[1], NULL);
|
24242
|
+
_v = SWIG_CheckState(res);
|
24243
|
+
}
|
24244
|
+
if (_v) {
|
24245
|
+
int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
|
24246
|
+
_v = SWIG_CheckState(res);
|
24247
|
+
if (_v) {
|
24248
|
+
return _wrap_DoubleVector2d_resize__SWIG_1(nargs, args, self);
|
24249
|
+
}
|
24250
|
+
}
|
24251
|
+
}
|
24252
|
+
}
|
24253
|
+
|
24254
|
+
fail:
|
24255
|
+
Ruby_Format_OverloadedError( argc, 4, "DoubleVector2d.resize",
|
24256
|
+
" void DoubleVector2d.resize(std::vector< std::vector< double > >::size_type new_size)\n"
|
24257
|
+
" void DoubleVector2d.resize(std::vector< std::vector< double > >::size_type new_size, std::vector< std::vector< double > >::value_type const &x)\n");
|
24258
|
+
|
24259
|
+
return Qnil;
|
24260
|
+
}
|
24261
|
+
|
24262
|
+
|
24263
|
+
|
24264
|
+
/*
|
24265
|
+
Document-method: Genmodel::DoubleVector2d.insert
|
24266
|
+
|
24267
|
+
call-seq:
|
24268
|
+
insert(pos, argc) -> DoubleVector2d
|
24269
|
+
insert(pos, x) -> std::vector< std::vector< double > >::iterator
|
24270
|
+
insert(pos, n, x)
|
24271
|
+
|
24272
|
+
Insert one or more new elements in the DoubleVector2d.
|
24273
|
+
*/
|
24274
|
+
SWIGINTERN VALUE
|
24275
|
+
_wrap_DoubleVector2d_insert__SWIG_1(int argc, VALUE *argv, VALUE self) {
|
24276
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
24277
|
+
std::vector< std::vector< double > >::iterator arg2 ;
|
24278
|
+
std::vector< std::vector< double > >::value_type *arg3 = 0 ;
|
24279
|
+
void *argp1 = 0 ;
|
24280
|
+
int res1 = 0 ;
|
24281
|
+
swig::Iterator *iter2 = 0 ;
|
24282
|
+
int res2 ;
|
24283
|
+
int res3 = SWIG_OLDOBJ ;
|
24284
|
+
std::vector< std::vector< double > >::iterator result;
|
24285
|
+
VALUE vresult = Qnil;
|
24286
|
+
|
24287
|
+
if ((argc < 2) || (argc > 2)) {
|
24288
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
24289
|
+
}
|
24290
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
24291
|
+
if (!SWIG_IsOK(res1)) {
|
24292
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","insert", 1, self ));
|
24293
|
+
}
|
24294
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
24295
|
+
res2 = SWIG_ConvertPtr(argv[0], SWIG_as_voidptrptr(&iter2), swig::Iterator::descriptor(), 0);
|
24296
|
+
if (!SWIG_IsOK(res2) || !iter2) {
|
24297
|
+
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::iterator","insert", 2, argv[0] ));
|
24298
|
+
} else {
|
24299
|
+
swig::Iterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::Iterator_T<std::vector< std::vector< double > >::iterator > *>(iter2);
|
24300
|
+
if (iter_t) {
|
24301
|
+
arg2 = iter_t->get_current();
|
24302
|
+
} else {
|
24303
|
+
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::iterator","insert", 2, argv[0] ));
|
24304
|
+
}
|
24305
|
+
}
|
24306
|
+
{
|
24307
|
+
std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
|
24308
|
+
res3 = swig::asptr(argv[1], &ptr);
|
24309
|
+
if (!SWIG_IsOK(res3)) {
|
24310
|
+
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::value_type const &","insert", 3, argv[1] ));
|
24311
|
+
}
|
24312
|
+
if (!ptr) {
|
24313
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::vector< double > >::value_type const &","insert", 3, argv[1]));
|
24314
|
+
}
|
24315
|
+
arg3 = ptr;
|
24316
|
+
}
|
24317
|
+
{
|
24318
|
+
try {
|
24319
|
+
result = (arg1)->insert(arg2,(std::vector< std::vector< double > >::value_type const &)*arg3);
|
24320
|
+
}
|
24321
|
+
catch(string str) {
|
24322
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24323
|
+
}
|
24324
|
+
catch(...) {
|
24325
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24326
|
+
}
|
24327
|
+
}
|
24328
|
+
vresult = SWIG_NewPointerObj(swig::make_nonconst_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result),
|
24329
|
+
self),
|
24330
|
+
swig::Iterator::descriptor(),SWIG_POINTER_OWN);
|
24331
|
+
if (SWIG_IsNewObj(res3)) delete arg3;
|
24332
|
+
return vresult;
|
24333
|
+
fail:
|
24334
|
+
if (SWIG_IsNewObj(res3)) delete arg3;
|
24335
|
+
return Qnil;
|
24336
|
+
}
|
24337
|
+
|
24338
|
+
|
24339
|
+
SWIGINTERN VALUE
|
24340
|
+
_wrap_DoubleVector2d_insert__SWIG_2(int argc, VALUE *argv, VALUE self) {
|
24341
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
24342
|
+
std::vector< std::vector< double > >::iterator arg2 ;
|
24343
|
+
std::vector< std::vector< double > >::size_type arg3 ;
|
24344
|
+
std::vector< std::vector< double > >::value_type *arg4 = 0 ;
|
24345
|
+
void *argp1 = 0 ;
|
24346
|
+
int res1 = 0 ;
|
24347
|
+
swig::Iterator *iter2 = 0 ;
|
24348
|
+
int res2 ;
|
24349
|
+
size_t val3 ;
|
24350
|
+
int ecode3 = 0 ;
|
24351
|
+
int res4 = SWIG_OLDOBJ ;
|
24352
|
+
|
24353
|
+
if ((argc < 3) || (argc > 3)) {
|
24354
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
|
24355
|
+
}
|
24356
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
24357
|
+
if (!SWIG_IsOK(res1)) {
|
24358
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","insert", 1, self ));
|
24359
|
+
}
|
24360
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
24361
|
+
res2 = SWIG_ConvertPtr(argv[0], SWIG_as_voidptrptr(&iter2), swig::Iterator::descriptor(), 0);
|
24362
|
+
if (!SWIG_IsOK(res2) || !iter2) {
|
24363
|
+
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::iterator","insert", 2, argv[0] ));
|
24364
|
+
} else {
|
24365
|
+
swig::Iterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::Iterator_T<std::vector< std::vector< double > >::iterator > *>(iter2);
|
24366
|
+
if (iter_t) {
|
24367
|
+
arg2 = iter_t->get_current();
|
24368
|
+
} else {
|
24369
|
+
SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::iterator","insert", 2, argv[0] ));
|
24370
|
+
}
|
24371
|
+
}
|
24372
|
+
ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
|
24373
|
+
if (!SWIG_IsOK(ecode3)) {
|
24374
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::size_type","insert", 3, argv[1] ));
|
24375
|
+
}
|
24376
|
+
arg3 = static_cast< std::vector< std::vector< double > >::size_type >(val3);
|
24377
|
+
{
|
24378
|
+
std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
|
24379
|
+
res4 = swig::asptr(argv[2], &ptr);
|
24380
|
+
if (!SWIG_IsOK(res4)) {
|
24381
|
+
SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::value_type const &","insert", 4, argv[2] ));
|
24382
|
+
}
|
24383
|
+
if (!ptr) {
|
24384
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< std::vector< double > >::value_type const &","insert", 4, argv[2]));
|
24385
|
+
}
|
24386
|
+
arg4 = ptr;
|
24387
|
+
}
|
24388
|
+
{
|
24389
|
+
try {
|
24390
|
+
(arg1)->insert(arg2,arg3,(std::vector< std::vector< double > >::value_type const &)*arg4);
|
24391
|
+
}
|
24392
|
+
catch(string str) {
|
24393
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24394
|
+
}
|
24395
|
+
catch(...) {
|
24396
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24397
|
+
}
|
24398
|
+
}
|
24399
|
+
if (SWIG_IsNewObj(res4)) delete arg4;
|
24400
|
+
return Qnil;
|
24401
|
+
fail:
|
24402
|
+
if (SWIG_IsNewObj(res4)) delete arg4;
|
24403
|
+
return Qnil;
|
24404
|
+
}
|
24405
|
+
|
24406
|
+
|
24407
|
+
SWIGINTERN VALUE _wrap_DoubleVector2d_insert(int nargs, VALUE *args, VALUE self) {
|
24408
|
+
int argc;
|
24409
|
+
VALUE argv[5];
|
24410
|
+
int ii;
|
24411
|
+
|
24412
|
+
argc = nargs + 1;
|
24413
|
+
argv[0] = self;
|
24414
|
+
if (argc > 5) SWIG_fail;
|
24415
|
+
for (ii = 1; (ii < argc); ++ii) {
|
24416
|
+
argv[ii] = args[ii-1];
|
24417
|
+
}
|
24418
|
+
if (argc == 3) {
|
24419
|
+
int _v;
|
24420
|
+
int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
|
24421
|
+
_v = SWIG_CheckState(res);
|
24422
|
+
if (_v) {
|
24423
|
+
swig::ConstIterator *iter = 0;
|
24424
|
+
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter),
|
24425
|
+
swig::Iterator::descriptor(), 0);
|
24426
|
+
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
|
24427
|
+
if (_v) {
|
24428
|
+
int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
|
24429
|
+
_v = SWIG_CheckState(res);
|
24430
|
+
if (_v) {
|
24431
|
+
return _wrap_DoubleVector2d_insert__SWIG_1(nargs, args, self);
|
24432
|
+
}
|
24433
|
+
}
|
24434
|
+
}
|
24435
|
+
}
|
24436
|
+
if (argc == 3) {
|
24437
|
+
int _v;
|
24438
|
+
int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
|
24439
|
+
_v = SWIG_CheckState(res);
|
24440
|
+
if (_v) {
|
24441
|
+
{
|
24442
|
+
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
|
24443
|
+
_v = SWIG_CheckState(res);
|
24444
|
+
}
|
24445
|
+
if (_v) {
|
24446
|
+
{
|
24447
|
+
int res = SWIG_AsVal_int(argv[2], NULL);
|
24448
|
+
_v = SWIG_CheckState(res);
|
24449
|
+
}
|
24450
|
+
if (_v) {
|
24451
|
+
if (argc <= 3) {
|
24452
|
+
return _wrap_DoubleVector2d_insert__SWIG_0(nargs, args, self);
|
24453
|
+
}
|
24454
|
+
return _wrap_DoubleVector2d_insert__SWIG_0(nargs, args, self);
|
24455
|
+
}
|
24456
|
+
}
|
24457
|
+
}
|
24458
|
+
}
|
24459
|
+
if (argc == 4) {
|
24460
|
+
int _v;
|
24461
|
+
int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
|
24462
|
+
_v = SWIG_CheckState(res);
|
24463
|
+
if (_v) {
|
24464
|
+
swig::ConstIterator *iter = 0;
|
24465
|
+
int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter),
|
24466
|
+
swig::Iterator::descriptor(), 0);
|
24467
|
+
_v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::Iterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
|
24468
|
+
if (_v) {
|
24469
|
+
{
|
24470
|
+
int res = SWIG_AsVal_size_t(argv[2], NULL);
|
24471
|
+
_v = SWIG_CheckState(res);
|
24472
|
+
}
|
24473
|
+
if (_v) {
|
24474
|
+
int res = swig::asptr(argv[3], (std::vector<double,std::allocator< double > >**)(0));
|
24475
|
+
_v = SWIG_CheckState(res);
|
24476
|
+
if (_v) {
|
24477
|
+
return _wrap_DoubleVector2d_insert__SWIG_2(nargs, args, self);
|
24478
|
+
}
|
24479
|
+
}
|
24480
|
+
}
|
24481
|
+
}
|
24482
|
+
}
|
24483
|
+
|
24484
|
+
fail:
|
24485
|
+
Ruby_Format_OverloadedError( argc, 5, "insert",
|
24486
|
+
" void insert(std::vector< std::vector< double > >::difference_type pos, int argc, VALUE *argv, ...)\n"
|
24487
|
+
" void insert(std::vector< std::vector< double > >::iterator pos, std::vector< std::vector< double > >::value_type const &x)\n"
|
24488
|
+
" void insert(std::vector< std::vector< double > >::iterator pos, std::vector< std::vector< double > >::size_type n, std::vector< std::vector< double > >::value_type const &x)\n");
|
24489
|
+
|
24490
|
+
return Qnil;
|
24491
|
+
}
|
24492
|
+
|
24493
|
+
|
24494
|
+
|
24495
|
+
/*
|
24496
|
+
Document-method: Genmodel::DoubleVector2d.reserve
|
24497
|
+
|
24498
|
+
call-seq:
|
24499
|
+
reserve(n)
|
24500
|
+
|
24501
|
+
Reserve memory in the DoubleVector2d for a number of elements.
|
24502
|
+
*/
|
24503
|
+
SWIGINTERN VALUE
|
24504
|
+
_wrap_DoubleVector2d_reserve(int argc, VALUE *argv, VALUE self) {
|
24505
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
24506
|
+
std::vector< std::vector< double > >::size_type arg2 ;
|
24507
|
+
void *argp1 = 0 ;
|
24508
|
+
int res1 = 0 ;
|
24509
|
+
size_t val2 ;
|
24510
|
+
int ecode2 = 0 ;
|
24511
|
+
|
24512
|
+
if ((argc < 1) || (argc > 1)) {
|
24513
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
24514
|
+
}
|
24515
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
24516
|
+
if (!SWIG_IsOK(res1)) {
|
24517
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > *","reserve", 1, self ));
|
24518
|
+
}
|
24519
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
24520
|
+
ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
|
24521
|
+
if (!SWIG_IsOK(ecode2)) {
|
24522
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< std::vector< double > >::size_type","reserve", 2, argv[0] ));
|
24523
|
+
}
|
24524
|
+
arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
|
24525
|
+
{
|
24526
|
+
try {
|
24527
|
+
(arg1)->reserve(arg2);
|
24528
|
+
}
|
24529
|
+
catch(string str) {
|
24530
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24531
|
+
}
|
24532
|
+
catch(...) {
|
24533
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24534
|
+
}
|
24535
|
+
}
|
24536
|
+
return Qnil;
|
24537
|
+
fail:
|
24538
|
+
return Qnil;
|
24539
|
+
}
|
24540
|
+
|
24541
|
+
|
24542
|
+
|
24543
|
+
/*
|
24544
|
+
Document-method: Genmodel::DoubleVector2d.capacity
|
24545
|
+
|
24546
|
+
call-seq:
|
24547
|
+
capacity -> std::vector< std::vector< double > >::size_type
|
24548
|
+
|
24549
|
+
Reserved capacity of the DoubleVector2d.
|
24550
|
+
*/
|
24551
|
+
SWIGINTERN VALUE
|
24552
|
+
_wrap_DoubleVector2d_capacity(int argc, VALUE *argv, VALUE self) {
|
24553
|
+
std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
|
24554
|
+
void *argp1 = 0 ;
|
24555
|
+
int res1 = 0 ;
|
24556
|
+
std::vector< std::vector< double > >::size_type result;
|
24557
|
+
VALUE vresult = Qnil;
|
24558
|
+
|
24559
|
+
if ((argc < 0) || (argc > 0)) {
|
24560
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
24561
|
+
}
|
24562
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0 | 0 );
|
24563
|
+
if (!SWIG_IsOK(res1)) {
|
24564
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< std::vector< double > > const *","capacity", 1, self ));
|
24565
|
+
}
|
24566
|
+
arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
|
24567
|
+
{
|
24568
|
+
try {
|
24569
|
+
result = ((std::vector< std::vector< double > > const *)arg1)->capacity();
|
24570
|
+
}
|
24571
|
+
catch(string str) {
|
24572
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24573
|
+
}
|
24574
|
+
catch(...) {
|
24575
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24576
|
+
}
|
24577
|
+
}
|
24578
|
+
vresult = SWIG_From_size_t(static_cast< size_t >(result));
|
24579
|
+
return vresult;
|
24580
|
+
fail:
|
24581
|
+
return Qnil;
|
24582
|
+
}
|
24583
|
+
|
24584
|
+
|
24585
|
+
SWIGINTERN void
|
24586
|
+
free_std_vector_Sl_std_vector_Sl_double_Sg__Sg_(std::vector< std::vector< double > > *arg1) {
|
24587
|
+
delete arg1;
|
24588
|
+
}
|
24589
|
+
|
24590
|
+
static swig_class SwigClassBoolVector;
|
24591
|
+
|
24592
|
+
|
24593
|
+
/*
|
24594
|
+
Document-method: Genmodel::BoolVector.dup
|
24595
|
+
|
24596
|
+
call-seq:
|
24597
|
+
dup -> BoolVector
|
24598
|
+
|
24599
|
+
Create a duplicate of the class and unfreeze it if needed.
|
24600
|
+
*/
|
24601
|
+
SWIGINTERN VALUE
|
24602
|
+
_wrap_BoolVector_dup(int argc, VALUE *argv, VALUE self) {
|
24603
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
24604
|
+
void *argp1 = 0 ;
|
24605
|
+
int res1 = 0 ;
|
24606
|
+
std::vector< bool,std::allocator< bool > > *result = 0 ;
|
24607
|
+
VALUE vresult = Qnil;
|
24608
|
+
|
24609
|
+
if ((argc < 0) || (argc > 0)) {
|
24610
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
24611
|
+
}
|
24612
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
24613
|
+
if (!SWIG_IsOK(res1)) {
|
24614
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","dup", 1, self ));
|
24615
|
+
}
|
24616
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
24617
|
+
{
|
24618
|
+
try {
|
24619
|
+
result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_Sg__dup(arg1);
|
24620
|
+
}
|
24621
|
+
catch(string str) {
|
24622
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24623
|
+
}
|
24624
|
+
catch(...) {
|
24625
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24626
|
+
}
|
24627
|
+
}
|
24628
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_OWN | 0 );
|
24629
|
+
return vresult;
|
24630
|
+
fail:
|
24631
|
+
return Qnil;
|
24632
|
+
}
|
24633
|
+
|
24634
|
+
|
24635
|
+
|
24636
|
+
/*
|
24637
|
+
Document-method: Genmodel::BoolVector.inspect
|
24638
|
+
|
24639
|
+
call-seq:
|
24640
|
+
inspect -> VALUE
|
24641
|
+
|
24642
|
+
Inspect class and its contents.
|
24643
|
+
*/
|
24644
|
+
SWIGINTERN VALUE
|
24645
|
+
_wrap_BoolVector_inspect(int argc, VALUE *argv, VALUE self) {
|
24646
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
24647
|
+
void *argp1 = 0 ;
|
24648
|
+
int res1 = 0 ;
|
24649
|
+
VALUE result;
|
24650
|
+
VALUE vresult = Qnil;
|
24651
|
+
|
24652
|
+
if ((argc < 0) || (argc > 0)) {
|
24653
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
24654
|
+
}
|
24655
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
24656
|
+
if (!SWIG_IsOK(res1)) {
|
24657
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","inspect", 1, self ));
|
24658
|
+
}
|
24659
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
24660
|
+
{
|
24661
|
+
try {
|
24662
|
+
result = (VALUE)std_vector_Sl_bool_Sg__inspect(arg1);
|
24663
|
+
}
|
24664
|
+
catch(string str) {
|
24665
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24666
|
+
}
|
24667
|
+
catch(...) {
|
24668
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24669
|
+
}
|
24670
|
+
}
|
24671
|
+
vresult = result;
|
24672
|
+
return vresult;
|
24673
|
+
fail:
|
24674
|
+
return Qnil;
|
24675
|
+
}
|
24676
|
+
|
24677
|
+
|
24678
|
+
|
24679
|
+
/*
|
24680
|
+
Document-method: Genmodel::BoolVector.to_a
|
24681
|
+
|
24682
|
+
call-seq:
|
24683
|
+
to_a -> VALUE
|
24684
|
+
|
24685
|
+
Convert BoolVector to an Array.
|
24686
|
+
*/
|
24687
|
+
SWIGINTERN VALUE
|
24688
|
+
_wrap_BoolVector_to_a(int argc, VALUE *argv, VALUE self) {
|
24689
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
24690
|
+
void *argp1 = 0 ;
|
24691
|
+
int res1 = 0 ;
|
24692
|
+
VALUE result;
|
24693
|
+
VALUE vresult = Qnil;
|
24694
|
+
|
24695
|
+
if ((argc < 0) || (argc > 0)) {
|
24696
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
24697
|
+
}
|
24698
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
24699
|
+
if (!SWIG_IsOK(res1)) {
|
24700
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","to_a", 1, self ));
|
24701
|
+
}
|
24702
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
24703
|
+
{
|
24704
|
+
try {
|
24705
|
+
result = (VALUE)std_vector_Sl_bool_Sg__to_a(arg1);
|
24706
|
+
}
|
24707
|
+
catch(string str) {
|
24708
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24709
|
+
}
|
24710
|
+
catch(...) {
|
24711
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24712
|
+
}
|
24713
|
+
}
|
24714
|
+
vresult = result;
|
24715
|
+
return vresult;
|
24716
|
+
fail:
|
24717
|
+
return Qnil;
|
24718
|
+
}
|
24719
|
+
|
24720
|
+
|
24721
|
+
|
24722
|
+
/*
|
24723
|
+
Document-method: Genmodel::BoolVector.to_s
|
24724
|
+
|
24725
|
+
call-seq:
|
24726
|
+
to_s -> VALUE
|
24727
|
+
|
24728
|
+
Convert class to a String representation.
|
24729
|
+
*/
|
24730
|
+
SWIGINTERN VALUE
|
24731
|
+
_wrap_BoolVector_to_s(int argc, VALUE *argv, VALUE self) {
|
24732
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
24733
|
+
void *argp1 = 0 ;
|
24734
|
+
int res1 = 0 ;
|
24735
|
+
VALUE result;
|
24736
|
+
VALUE vresult = Qnil;
|
24737
|
+
|
24738
|
+
if ((argc < 0) || (argc > 0)) {
|
24739
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
24740
|
+
}
|
24741
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
24742
|
+
if (!SWIG_IsOK(res1)) {
|
24743
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","to_s", 1, self ));
|
24744
|
+
}
|
24745
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
24746
|
+
{
|
24747
|
+
try {
|
24748
|
+
result = (VALUE)std_vector_Sl_bool_Sg__to_s(arg1);
|
24749
|
+
}
|
24750
|
+
catch(string str) {
|
24751
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24752
|
+
}
|
24753
|
+
catch(...) {
|
24754
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24755
|
+
}
|
24756
|
+
}
|
24757
|
+
vresult = result;
|
24758
|
+
return vresult;
|
24759
|
+
fail:
|
24760
|
+
return Qnil;
|
24761
|
+
}
|
24762
|
+
|
24763
|
+
|
24764
|
+
|
24765
|
+
/*
|
24766
|
+
Document-method: Genmodel::BoolVector.slice
|
24767
|
+
|
24768
|
+
call-seq:
|
24769
|
+
slice(i, j) -> VALUE
|
24770
|
+
|
24771
|
+
Return a slice (portion of) the BoolVector.
|
24772
|
+
*/
|
24773
|
+
SWIGINTERN VALUE
|
24774
|
+
_wrap_BoolVector_slice(int argc, VALUE *argv, VALUE self) {
|
24775
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
24776
|
+
std::vector< bool >::difference_type arg2 ;
|
24777
|
+
std::vector< bool >::difference_type arg3 ;
|
24778
|
+
void *argp1 = 0 ;
|
24779
|
+
int res1 = 0 ;
|
24780
|
+
ptrdiff_t val2 ;
|
24781
|
+
int ecode2 = 0 ;
|
24782
|
+
ptrdiff_t val3 ;
|
24783
|
+
int ecode3 = 0 ;
|
24784
|
+
VALUE result;
|
24785
|
+
VALUE vresult = Qnil;
|
24786
|
+
|
24787
|
+
if ((argc < 2) || (argc > 2)) {
|
24788
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
24789
|
+
}
|
24790
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
24791
|
+
if (!SWIG_IsOK(res1)) {
|
24792
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","slice", 1, self ));
|
24793
|
+
}
|
24794
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
24795
|
+
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
24796
|
+
if (!SWIG_IsOK(ecode2)) {
|
24797
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< bool >::difference_type","slice", 2, argv[0] ));
|
24798
|
+
}
|
24799
|
+
arg2 = static_cast< std::vector< bool >::difference_type >(val2);
|
24800
|
+
ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
|
24801
|
+
if (!SWIG_IsOK(ecode3)) {
|
24802
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< bool >::difference_type","slice", 3, argv[1] ));
|
24803
|
+
}
|
24804
|
+
arg3 = static_cast< std::vector< bool >::difference_type >(val3);
|
24805
|
+
{
|
24806
|
+
try {
|
24807
|
+
result = (VALUE)std_vector_Sl_bool_Sg__slice(arg1,arg2,arg3);
|
24808
|
+
}
|
24809
|
+
catch(string str) {
|
24810
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24811
|
+
}
|
24812
|
+
catch(...) {
|
24813
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24814
|
+
}
|
24815
|
+
}
|
24816
|
+
vresult = result;
|
24817
|
+
return vresult;
|
24818
|
+
fail:
|
24819
|
+
return Qnil;
|
24820
|
+
}
|
24821
|
+
|
24822
|
+
|
24823
|
+
|
24824
|
+
/*
|
24825
|
+
Document-method: Genmodel::BoolVector.each
|
24826
|
+
|
24827
|
+
call-seq:
|
24828
|
+
each -> BoolVector
|
24829
|
+
|
24830
|
+
Iterate thru each element in the BoolVector. A block must be provided.
|
24831
|
+
*/
|
24832
|
+
SWIGINTERN VALUE
|
24833
|
+
_wrap_BoolVector_each(int argc, VALUE *argv, VALUE self) {
|
24834
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
24835
|
+
void *argp1 = 0 ;
|
24836
|
+
int res1 = 0 ;
|
24837
|
+
std::vector< bool,std::allocator< bool > > *result = 0 ;
|
24838
|
+
VALUE vresult = Qnil;
|
24839
|
+
|
24840
|
+
if ((argc < 0) || (argc > 0)) {
|
24841
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
24842
|
+
}
|
24843
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
24844
|
+
if (!SWIG_IsOK(res1)) {
|
24845
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","each", 1, self ));
|
24846
|
+
}
|
24847
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
24848
|
+
{
|
24849
|
+
try {
|
24850
|
+
result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_Sg__each(arg1);
|
24851
|
+
}
|
24852
|
+
catch(string str) {
|
24853
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24854
|
+
}
|
24855
|
+
catch(...) {
|
24856
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24857
|
+
}
|
24858
|
+
}
|
24859
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
24860
|
+
return vresult;
|
24861
|
+
fail:
|
24862
|
+
return Qnil;
|
24863
|
+
}
|
24864
|
+
|
24865
|
+
|
24866
|
+
|
24867
|
+
/*
|
24868
|
+
Document-method: Genmodel::BoolVector.select
|
24869
|
+
|
24870
|
+
call-seq:
|
24871
|
+
select -> BoolVector
|
24872
|
+
|
24873
|
+
Iterate thru each element in the BoolVector and select those that match a condition. A block must be provided.
|
24874
|
+
*/
|
24875
|
+
SWIGINTERN VALUE
|
24876
|
+
_wrap_BoolVector_select(int argc, VALUE *argv, VALUE self) {
|
24877
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
24878
|
+
void *argp1 = 0 ;
|
24879
|
+
int res1 = 0 ;
|
24880
|
+
std::vector< bool,std::allocator< bool > > *result = 0 ;
|
24881
|
+
VALUE vresult = Qnil;
|
24882
|
+
|
24883
|
+
if ((argc < 0) || (argc > 0)) {
|
24884
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
24885
|
+
}
|
24886
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
24887
|
+
if (!SWIG_IsOK(res1)) {
|
24888
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","select", 1, self ));
|
24889
|
+
}
|
24890
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
24891
|
+
{
|
24892
|
+
try {
|
24893
|
+
result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_Sg__select(arg1);
|
24894
|
+
}
|
24895
|
+
catch(string str) {
|
24896
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24897
|
+
}
|
24898
|
+
catch(...) {
|
24899
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24900
|
+
}
|
24901
|
+
}
|
24902
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_OWN | 0 );
|
24903
|
+
return vresult;
|
24904
|
+
fail:
|
24905
|
+
return Qnil;
|
24906
|
+
}
|
24907
|
+
|
24908
|
+
|
24909
|
+
|
24910
|
+
/*
|
24911
|
+
Document-method: Genmodel::BoolVector.delete_at
|
24912
|
+
|
24913
|
+
call-seq:
|
24914
|
+
delete_at(i) -> VALUE
|
24915
|
+
|
24916
|
+
Delete an element at a certain index.
|
24917
|
+
*/
|
24918
|
+
SWIGINTERN VALUE
|
24919
|
+
_wrap_BoolVector_delete_at(int argc, VALUE *argv, VALUE self) {
|
24920
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
24921
|
+
std::vector< bool >::difference_type arg2 ;
|
24922
|
+
void *argp1 = 0 ;
|
24923
|
+
int res1 = 0 ;
|
24924
|
+
ptrdiff_t val2 ;
|
24925
|
+
int ecode2 = 0 ;
|
24926
|
+
VALUE result;
|
24927
|
+
VALUE vresult = Qnil;
|
24928
|
+
|
24929
|
+
if ((argc < 1) || (argc > 1)) {
|
24930
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
24931
|
+
}
|
24932
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
24933
|
+
if (!SWIG_IsOK(res1)) {
|
24934
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","delete_at", 1, self ));
|
24935
|
+
}
|
24936
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
24937
|
+
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
24938
|
+
if (!SWIG_IsOK(ecode2)) {
|
24939
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< bool >::difference_type","delete_at", 2, argv[0] ));
|
24940
|
+
}
|
24941
|
+
arg2 = static_cast< std::vector< bool >::difference_type >(val2);
|
24942
|
+
{
|
24943
|
+
try {
|
24944
|
+
result = (VALUE)std_vector_Sl_bool_Sg__delete_at(arg1,arg2);
|
24945
|
+
}
|
24946
|
+
catch(string str) {
|
24947
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24948
|
+
}
|
24949
|
+
catch(...) {
|
24950
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24951
|
+
}
|
24952
|
+
}
|
24953
|
+
vresult = result;
|
24954
|
+
return vresult;
|
24955
|
+
fail:
|
24956
|
+
return Qnil;
|
24957
|
+
}
|
24958
|
+
|
24959
|
+
|
24960
|
+
SWIGINTERN VALUE
|
24961
|
+
_wrap_BoolVector___delete2__(int argc, VALUE *argv, VALUE self) {
|
24962
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
24963
|
+
std::vector< bool >::value_type *arg2 = 0 ;
|
24964
|
+
void *argp1 = 0 ;
|
24965
|
+
int res1 = 0 ;
|
24966
|
+
std::vector< bool >::value_type temp2 ;
|
24967
|
+
bool val2 ;
|
24968
|
+
int ecode2 = 0 ;
|
24969
|
+
VALUE result;
|
24970
|
+
VALUE vresult = Qnil;
|
24971
|
+
|
24972
|
+
if ((argc < 1) || (argc > 1)) {
|
24973
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
24974
|
+
}
|
24975
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
24976
|
+
if (!SWIG_IsOK(res1)) {
|
24977
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","__delete2__", 1, self ));
|
24978
|
+
}
|
24979
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
24980
|
+
ecode2 = SWIG_AsVal_bool(argv[0], &val2);
|
24981
|
+
if (!SWIG_IsOK(ecode2)) {
|
24982
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< bool >::value_type","__delete2__", 2, argv[0] ));
|
24983
|
+
}
|
24984
|
+
temp2 = static_cast< std::vector< bool >::value_type >(val2);
|
24985
|
+
arg2 = &temp2;
|
24986
|
+
{
|
24987
|
+
try {
|
24988
|
+
result = (VALUE)std_vector_Sl_bool_Sg____delete2__(arg1,(bool const &)*arg2);
|
24989
|
+
}
|
24990
|
+
catch(string str) {
|
24991
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
24992
|
+
}
|
24993
|
+
catch(...) {
|
24994
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
24995
|
+
}
|
24996
|
+
}
|
24997
|
+
vresult = result;
|
24998
|
+
return vresult;
|
24999
|
+
fail:
|
25000
|
+
return Qnil;
|
25001
|
+
}
|
25002
|
+
|
25003
|
+
|
25004
|
+
|
25005
|
+
/*
|
25006
|
+
Document-method: Genmodel::BoolVector.reject!
|
25007
|
+
|
25008
|
+
call-seq:
|
25009
|
+
reject! -> BoolVector
|
25010
|
+
|
25011
|
+
Iterate thru each element in the BoolVector and reject those that fail a condition. A block must be provided. BoolVector is modified in place.
|
25012
|
+
*/
|
25013
|
+
SWIGINTERN VALUE
|
25014
|
+
_wrap_BoolVector_rejectN___(int argc, VALUE *argv, VALUE self) {
|
25015
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
25016
|
+
void *argp1 = 0 ;
|
25017
|
+
int res1 = 0 ;
|
25018
|
+
std::vector< bool,std::allocator< bool > > *result = 0 ;
|
25019
|
+
VALUE vresult = Qnil;
|
25020
|
+
|
25021
|
+
if ((argc < 0) || (argc > 0)) {
|
25022
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
25023
|
+
}
|
25024
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
25025
|
+
if (!SWIG_IsOK(res1)) {
|
25026
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","reject_bang", 1, self ));
|
25027
|
+
}
|
25028
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
25029
|
+
{
|
25030
|
+
try {
|
25031
|
+
result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_Sg__reject_bang(arg1);
|
25032
|
+
}
|
25033
|
+
catch(string str) {
|
25034
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
25035
|
+
}
|
25036
|
+
catch(...) {
|
25037
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
25038
|
+
}
|
25039
|
+
}
|
25040
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
25041
|
+
return vresult;
|
25042
|
+
fail:
|
25043
|
+
return Qnil;
|
25044
|
+
}
|
25045
|
+
|
25046
|
+
|
25047
|
+
|
25048
|
+
/*
|
25049
|
+
Document-method: Genmodel::BoolVector.pop
|
25050
|
+
|
25051
|
+
call-seq:
|
25052
|
+
pop -> VALUE
|
25053
|
+
|
25054
|
+
Remove and return element at the end of the BoolVector.
|
25055
|
+
*/
|
25056
|
+
SWIGINTERN VALUE
|
25057
|
+
_wrap_BoolVector_pop(int argc, VALUE *argv, VALUE self) {
|
25058
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
25059
|
+
void *argp1 = 0 ;
|
25060
|
+
int res1 = 0 ;
|
25061
|
+
VALUE result;
|
25062
|
+
VALUE vresult = Qnil;
|
25063
|
+
|
25064
|
+
if ((argc < 0) || (argc > 0)) {
|
25065
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
25066
|
+
}
|
25067
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
25068
|
+
if (!SWIG_IsOK(res1)) {
|
25069
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","pop", 1, self ));
|
25070
|
+
}
|
25071
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
25072
|
+
{
|
25073
|
+
try {
|
25074
|
+
result = (VALUE)std_vector_Sl_bool_Sg__pop(arg1);
|
25075
|
+
}
|
25076
|
+
catch(string str) {
|
25077
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
25078
|
+
}
|
25079
|
+
catch(...) {
|
25080
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
25081
|
+
}
|
25082
|
+
}
|
25083
|
+
vresult = result;
|
25084
|
+
return vresult;
|
25085
|
+
fail:
|
25086
|
+
return Qnil;
|
25087
|
+
}
|
25088
|
+
|
25089
|
+
|
25090
|
+
|
25091
|
+
/*
|
25092
|
+
Document-method: Genmodel::BoolVector.push
|
25093
|
+
|
25094
|
+
call-seq:
|
25095
|
+
push(e) -> std::vector< bool >::value_type const
|
25096
|
+
|
25097
|
+
Add an element at the end of the BoolVector.
|
25098
|
+
*/
|
25099
|
+
SWIGINTERN VALUE
|
25100
|
+
_wrap_BoolVector_push(int argc, VALUE *argv, VALUE self) {
|
25101
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
25102
|
+
std::vector< bool >::value_type *arg2 = 0 ;
|
25103
|
+
void *argp1 = 0 ;
|
25104
|
+
int res1 = 0 ;
|
25105
|
+
std::vector< bool >::value_type temp2 ;
|
25106
|
+
bool val2 ;
|
25107
|
+
int ecode2 = 0 ;
|
25108
|
+
std::vector< bool >::value_type result;
|
25109
|
+
VALUE vresult = Qnil;
|
25110
|
+
|
25111
|
+
if ((argc < 1) || (argc > 1)) {
|
25112
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
25113
|
+
}
|
25114
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
25115
|
+
if (!SWIG_IsOK(res1)) {
|
25116
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","push", 1, self ));
|
25117
|
+
}
|
25118
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
25119
|
+
ecode2 = SWIG_AsVal_bool(argv[0], &val2);
|
25120
|
+
if (!SWIG_IsOK(ecode2)) {
|
25121
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< bool >::value_type","push", 2, argv[0] ));
|
25122
|
+
}
|
25123
|
+
temp2 = static_cast< std::vector< bool >::value_type >(val2);
|
25124
|
+
arg2 = &temp2;
|
25125
|
+
{
|
25126
|
+
try {
|
25127
|
+
result = (std::vector< bool >::value_type)std_vector_Sl_bool_Sg__push(arg1,(bool const &)*arg2);
|
25128
|
+
}
|
25129
|
+
catch(string str) {
|
25130
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
25131
|
+
}
|
25132
|
+
catch(...) {
|
25133
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
25134
|
+
}
|
25135
|
+
}
|
25136
|
+
vresult = SWIG_From_bool(static_cast< bool >(result));
|
25137
|
+
return vresult;
|
25138
|
+
fail:
|
25139
|
+
return Qnil;
|
25140
|
+
}
|
25141
|
+
|
25142
|
+
|
25143
|
+
|
25144
|
+
/*
|
25145
|
+
Document-method: Genmodel::BoolVector.reject
|
25146
|
+
|
25147
|
+
call-seq:
|
25148
|
+
reject -> BoolVector
|
25149
|
+
|
25150
|
+
Iterate thru each element in the BoolVector and reject those that fail a condition returning a new BoolVector. A block must be provided.
|
25151
|
+
*/
|
25152
|
+
SWIGINTERN VALUE
|
25153
|
+
_wrap_BoolVector_reject(int argc, VALUE *argv, VALUE self) {
|
25154
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
25155
|
+
void *argp1 = 0 ;
|
25156
|
+
int res1 = 0 ;
|
25157
|
+
std::vector< bool,std::allocator< bool > > *result = 0 ;
|
25158
|
+
VALUE vresult = Qnil;
|
25159
|
+
|
25160
|
+
if ((argc < 0) || (argc > 0)) {
|
25161
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
|
25162
|
+
}
|
25163
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
25164
|
+
if (!SWIG_IsOK(res1)) {
|
25165
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","reject", 1, self ));
|
25166
|
+
}
|
25167
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
25168
|
+
{
|
25169
|
+
try {
|
25170
|
+
result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_Sg__reject(arg1);
|
25171
|
+
}
|
25172
|
+
catch(string str) {
|
25173
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
25174
|
+
}
|
25175
|
+
catch(...) {
|
25176
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
25177
|
+
}
|
25178
|
+
}
|
25179
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_OWN | 0 );
|
25180
|
+
return vresult;
|
25181
|
+
fail:
|
25182
|
+
return Qnil;
|
25183
|
+
}
|
25184
|
+
|
25185
|
+
|
25186
|
+
|
25187
|
+
/*
|
25188
|
+
Document-method: Genmodel::BoolVector.at
|
25189
|
+
|
25190
|
+
call-seq:
|
25191
|
+
at(i) -> VALUE
|
25192
|
+
|
25193
|
+
Return element at a certain index.
|
25194
|
+
*/
|
25195
|
+
SWIGINTERN VALUE
|
25196
|
+
_wrap_BoolVector_at(int argc, VALUE *argv, VALUE self) {
|
25197
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
25198
|
+
std::vector< bool >::difference_type arg2 ;
|
25199
|
+
void *argp1 = 0 ;
|
25200
|
+
int res1 = 0 ;
|
25201
|
+
ptrdiff_t val2 ;
|
25202
|
+
int ecode2 = 0 ;
|
25203
|
+
VALUE result;
|
25204
|
+
VALUE vresult = Qnil;
|
25205
|
+
|
25206
|
+
if ((argc < 1) || (argc > 1)) {
|
25207
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
25208
|
+
}
|
25209
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
25210
|
+
if (!SWIG_IsOK(res1)) {
|
25211
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > const *","at", 1, self ));
|
25212
|
+
}
|
25213
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
25214
|
+
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
25215
|
+
if (!SWIG_IsOK(ecode2)) {
|
25216
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< bool >::difference_type","at", 2, argv[0] ));
|
25217
|
+
}
|
25218
|
+
arg2 = static_cast< std::vector< bool >::difference_type >(val2);
|
25219
|
+
{
|
25220
|
+
try {
|
25221
|
+
result = (VALUE)std_vector_Sl_bool_Sg__at((std::vector< bool > const *)arg1,arg2);
|
25222
|
+
}
|
25223
|
+
catch(string str) {
|
25224
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
25225
|
+
}
|
25226
|
+
catch(...) {
|
25227
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
25228
|
+
}
|
25229
|
+
}
|
25230
|
+
vresult = result;
|
25231
|
+
return vresult;
|
25232
|
+
fail:
|
25233
|
+
return Qnil;
|
25234
|
+
}
|
25235
|
+
|
25236
|
+
|
25237
|
+
|
25238
|
+
/*
|
25239
|
+
Document-method: Genmodel::BoolVector.[]
|
25240
|
+
|
25241
|
+
call-seq:
|
25242
|
+
[](i, j) -> VALUE
|
25243
|
+
[](i) -> VALUE
|
25244
|
+
[](i) -> VALUE
|
25245
|
+
|
25246
|
+
Element accessor/slicing.
|
25247
|
+
*/
|
25248
|
+
SWIGINTERN VALUE
|
25249
|
+
_wrap_BoolVector___getitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
|
25250
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
25251
|
+
std::vector< bool >::difference_type arg2 ;
|
25252
|
+
std::vector< bool >::difference_type arg3 ;
|
25253
|
+
void *argp1 = 0 ;
|
25254
|
+
int res1 = 0 ;
|
25255
|
+
ptrdiff_t val2 ;
|
25256
|
+
int ecode2 = 0 ;
|
25257
|
+
ptrdiff_t val3 ;
|
25258
|
+
int ecode3 = 0 ;
|
25259
|
+
VALUE result;
|
25260
|
+
VALUE vresult = Qnil;
|
25261
|
+
|
25262
|
+
if ((argc < 2) || (argc > 2)) {
|
25263
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
25264
|
+
}
|
25265
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
25266
|
+
if (!SWIG_IsOK(res1)) {
|
25267
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > const *","__getitem__", 1, self ));
|
25268
|
+
}
|
25269
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
25270
|
+
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
25271
|
+
if (!SWIG_IsOK(ecode2)) {
|
25272
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< bool >::difference_type","__getitem__", 2, argv[0] ));
|
25273
|
+
}
|
25274
|
+
arg2 = static_cast< std::vector< bool >::difference_type >(val2);
|
25275
|
+
ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
|
25276
|
+
if (!SWIG_IsOK(ecode3)) {
|
25277
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< bool >::difference_type","__getitem__", 3, argv[1] ));
|
25278
|
+
}
|
25279
|
+
arg3 = static_cast< std::vector< bool >::difference_type >(val3);
|
25280
|
+
{
|
25281
|
+
try {
|
25282
|
+
result = (VALUE)std_vector_Sl_bool_Sg____getitem____SWIG_0((std::vector< bool > const *)arg1,arg2,arg3);
|
25283
|
+
}
|
25284
|
+
catch(string str) {
|
25285
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
25286
|
+
}
|
25287
|
+
catch(...) {
|
25288
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
25289
|
+
}
|
25290
|
+
}
|
25291
|
+
vresult = result;
|
25292
|
+
return vresult;
|
25293
|
+
fail:
|
25294
|
+
return Qnil;
|
25295
|
+
}
|
25296
|
+
|
25297
|
+
|
25298
|
+
SWIGINTERN VALUE
|
25299
|
+
_wrap_BoolVector___getitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
|
25300
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
25301
|
+
std::vector< bool >::difference_type arg2 ;
|
25302
|
+
void *argp1 = 0 ;
|
25303
|
+
int res1 = 0 ;
|
25304
|
+
ptrdiff_t val2 ;
|
25305
|
+
int ecode2 = 0 ;
|
25306
|
+
VALUE result;
|
25307
|
+
VALUE vresult = Qnil;
|
25308
|
+
|
25309
|
+
if ((argc < 1) || (argc > 1)) {
|
25310
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
25311
|
+
}
|
25312
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
25313
|
+
if (!SWIG_IsOK(res1)) {
|
25314
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > const *","__getitem__", 1, self ));
|
25315
|
+
}
|
25316
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
25317
|
+
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
25318
|
+
if (!SWIG_IsOK(ecode2)) {
|
25319
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< bool >::difference_type","__getitem__", 2, argv[0] ));
|
25320
|
+
}
|
25321
|
+
arg2 = static_cast< std::vector< bool >::difference_type >(val2);
|
25322
|
+
{
|
25323
|
+
try {
|
25324
|
+
result = (VALUE)std_vector_Sl_bool_Sg____getitem____SWIG_1((std::vector< bool > const *)arg1,arg2);
|
25325
|
+
}
|
25326
|
+
catch(string str) {
|
25327
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
25328
|
+
}
|
25329
|
+
catch(...) {
|
25330
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
25331
|
+
}
|
25332
|
+
}
|
25333
|
+
vresult = result;
|
25334
|
+
return vresult;
|
25335
|
+
fail:
|
25336
|
+
return Qnil;
|
25337
|
+
}
|
25338
|
+
|
25339
|
+
|
25340
|
+
SWIGINTERN VALUE
|
25341
|
+
_wrap_BoolVector___getitem____SWIG_2(int argc, VALUE *argv, VALUE self) {
|
25342
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
25343
|
+
VALUE arg2 = (VALUE) 0 ;
|
25344
|
+
void *argp1 = 0 ;
|
25345
|
+
int res1 = 0 ;
|
25346
|
+
VALUE result;
|
25347
|
+
VALUE vresult = Qnil;
|
25348
|
+
|
25349
|
+
if ((argc < 1) || (argc > 1)) {
|
25350
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
25351
|
+
}
|
25352
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
25353
|
+
if (!SWIG_IsOK(res1)) {
|
25354
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > const *","__getitem__", 1, self ));
|
25355
|
+
}
|
25356
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
25357
|
+
arg2 = argv[0];
|
25358
|
+
{
|
25359
|
+
try {
|
25360
|
+
result = (VALUE)std_vector_Sl_bool_Sg____getitem____SWIG_2((std::vector< bool > const *)arg1,arg2);
|
25361
|
+
}
|
25362
|
+
catch(string str) {
|
25363
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
25364
|
+
}
|
25365
|
+
catch(...) {
|
25366
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
25367
|
+
}
|
25368
|
+
}
|
25369
|
+
vresult = result;
|
25370
|
+
return vresult;
|
25371
|
+
fail:
|
25372
|
+
return Qnil;
|
25373
|
+
}
|
25374
|
+
|
25375
|
+
|
25376
|
+
SWIGINTERN VALUE _wrap_BoolVector___getitem__(int nargs, VALUE *args, VALUE self) {
|
25377
|
+
int argc;
|
25378
|
+
VALUE argv[4];
|
25379
|
+
int ii;
|
25380
|
+
|
25381
|
+
argc = nargs + 1;
|
25382
|
+
argv[0] = self;
|
25383
|
+
if (argc > 4) SWIG_fail;
|
25384
|
+
for (ii = 1; (ii < argc); ++ii) {
|
25385
|
+
argv[ii] = args[ii-1];
|
25386
|
+
}
|
25387
|
+
if (argc == 2) {
|
25388
|
+
int _v;
|
25389
|
+
int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
|
25390
|
+
_v = SWIG_CheckState(res);
|
25391
|
+
if (_v) {
|
25392
|
+
{
|
25393
|
+
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
|
25394
|
+
_v = SWIG_CheckState(res);
|
25395
|
+
}
|
25396
|
+
if (_v) {
|
25397
|
+
return _wrap_BoolVector___getitem____SWIG_1(nargs, args, self);
|
25398
|
+
}
|
25399
|
+
}
|
25400
|
+
}
|
25401
|
+
if (argc == 2) {
|
25402
|
+
int _v;
|
25403
|
+
int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
|
25404
|
+
_v = SWIG_CheckState(res);
|
25405
|
+
if (_v) {
|
25406
|
+
_v = (argv[1] != 0);
|
25407
|
+
if (_v) {
|
25408
|
+
return _wrap_BoolVector___getitem____SWIG_2(nargs, args, self);
|
25409
|
+
}
|
25410
|
+
}
|
25411
|
+
}
|
25412
|
+
if (argc == 3) {
|
25413
|
+
int _v;
|
25414
|
+
int res = swig::asptr(argv[0], (std::vector<bool,std::allocator< bool > >**)(0));
|
25415
|
+
_v = SWIG_CheckState(res);
|
25416
|
+
if (_v) {
|
25417
|
+
{
|
25418
|
+
int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
|
25419
|
+
_v = SWIG_CheckState(res);
|
25420
|
+
}
|
25421
|
+
if (_v) {
|
25422
|
+
{
|
25423
|
+
int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
|
25424
|
+
_v = SWIG_CheckState(res);
|
25425
|
+
}
|
25426
|
+
if (_v) {
|
25427
|
+
return _wrap_BoolVector___getitem____SWIG_0(nargs, args, self);
|
25428
|
+
}
|
25429
|
+
}
|
25430
|
+
}
|
25431
|
+
}
|
25432
|
+
|
25433
|
+
fail:
|
25434
|
+
Ruby_Format_OverloadedError( argc, 4, "__getitem__",
|
25435
|
+
" VALUE __getitem__(std::vector< bool >::difference_type i, std::vector< bool >::difference_type j)\n"
|
25436
|
+
" VALUE __getitem__(std::vector< bool >::difference_type i)\n"
|
25437
|
+
" VALUE __getitem__(VALUE i)\n");
|
25438
|
+
|
25439
|
+
return Qnil;
|
25440
|
+
}
|
25441
|
+
|
25442
|
+
|
25443
|
+
|
25444
|
+
/*
|
25445
|
+
Document-method: Genmodel::BoolVector.[]=
|
25446
|
+
|
25447
|
+
call-seq:
|
25448
|
+
[]=(i, x) -> VALUE
|
25449
|
+
[]=(i, j, v) -> VALUE
|
25450
|
+
|
25451
|
+
Element setter/slicing.
|
25452
|
+
*/
|
25453
|
+
SWIGINTERN VALUE
|
25454
|
+
_wrap_BoolVector___setitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
|
25455
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
25456
|
+
std::vector< bool >::difference_type arg2 ;
|
25457
|
+
std::vector< bool >::value_type *arg3 = 0 ;
|
25458
|
+
void *argp1 = 0 ;
|
25459
|
+
int res1 = 0 ;
|
25460
|
+
ptrdiff_t val2 ;
|
25461
|
+
int ecode2 = 0 ;
|
25462
|
+
std::vector< bool >::value_type temp3 ;
|
25463
|
+
bool val3 ;
|
25464
|
+
int ecode3 = 0 ;
|
25465
|
+
VALUE result;
|
25466
|
+
VALUE vresult = Qnil;
|
25467
|
+
|
25468
|
+
if ((argc < 2) || (argc > 2)) {
|
25469
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
25470
|
+
}
|
25471
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
25472
|
+
if (!SWIG_IsOK(res1)) {
|
25473
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","__setitem__", 1, self ));
|
25474
|
+
}
|
25475
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
25476
|
+
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
25477
|
+
if (!SWIG_IsOK(ecode2)) {
|
25478
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< bool >::difference_type","__setitem__", 2, argv[0] ));
|
25479
|
+
}
|
25480
|
+
arg2 = static_cast< std::vector< bool >::difference_type >(val2);
|
25481
|
+
ecode3 = SWIG_AsVal_bool(argv[1], &val3);
|
25482
|
+
if (!SWIG_IsOK(ecode3)) {
|
25483
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< bool >::value_type","__setitem__", 3, argv[1] ));
|
25484
|
+
}
|
25485
|
+
temp3 = static_cast< std::vector< bool >::value_type >(val3);
|
25486
|
+
arg3 = &temp3;
|
25487
|
+
{
|
25488
|
+
try {
|
25489
|
+
result = (VALUE)std_vector_Sl_bool_Sg____setitem____SWIG_0(arg1,arg2,(bool const &)*arg3);
|
25490
|
+
}
|
25491
|
+
catch(string str) {
|
25492
|
+
SWIG_exception(SWIG_RuntimeError,str.c_str());
|
25493
|
+
}
|
25494
|
+
catch(...) {
|
25495
|
+
SWIG_exception(SWIG_RuntimeError,"Unknown exception");
|
25496
|
+
}
|
25497
|
+
}
|
25498
|
+
vresult = result;
|
25499
|
+
return vresult;
|
25500
|
+
fail:
|
25501
|
+
return Qnil;
|
25502
|
+
}
|
25503
|
+
|
25504
|
+
|
25505
|
+
SWIGINTERN VALUE
|
25506
|
+
_wrap_BoolVector___setitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
|
25507
|
+
std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
|
25508
|
+
std::vector< bool >::difference_type arg2 ;
|
25509
|
+
std::vector< bool >::difference_type arg3 ;
|
25510
|
+
std::vector< bool,std::allocator< bool > > *arg4 = 0 ;
|
25511
|
+
void *argp1 = 0 ;
|
25512
|
+
int res1 = 0 ;
|
25513
|
+
ptrdiff_t val2 ;
|
25514
|
+
int ecode2 = 0 ;
|
25515
|
+
ptrdiff_t val3 ;
|
25516
|
+
int ecode3 = 0 ;
|
25517
|
+
int res4 = SWIG_OLDOBJ ;
|
25518
|
+
VALUE result;
|
25519
|
+
VALUE vresult = Qnil;
|
25520
|
+
|
25521
|
+
if ((argc < 3) || (argc > 3)) {
|
25522
|
+
rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
|
25523
|
+
}
|
25524
|
+
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
|
25525
|
+
if (!SWIG_IsOK(res1)) {
|
25526
|
+
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::vector< bool > *","__setitem__", 1, self ));
|
25527
|
+
}
|
25528
|
+
arg1 = reinterpret_cast< std::vector< bool > * >(argp1);
|
25529
|
+
ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
|
25530
|
+
if (!SWIG_IsOK(ecode2)) {
|
25531
|
+
SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "std::vector< bool >::difference_type","__setitem__", 2, argv[0] ));
|
25532
|
+
}
|
25533
|
+
arg2 = static_cast< std::vector< bool >::difference_type >(val2);
|
25534
|
+
ecode3 = SWIG_AsVal_ptrdiff_t(argv[1], &val3);
|
25535
|
+
if (!SWIG_IsOK(ecode3)) {
|
25536
|
+
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "std::vector< bool >::difference_type","__setitem__", 3, argv[1] ));
|
25537
|
+
}
|
25538
|
+
arg3 = static_cast< std::vector< bool >::difference_type >(val3);
|
25539
|
+
{
|
25540
|
+
std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
|
25541
|
+
res4 = swig::asptr(argv[2], &ptr);
|
25542
|
+
if (!SWIG_IsOK(res4)) {
|
25543
|
+
SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::vector< bool,std::allocator< bool > > const &","__setitem__", 4, argv[2] ));
|
25544
|
+
}
|
25545
|
+
if (!ptr) {
|
25546
|
+
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::vector< bool,std::allocator< bool > > const &","__setitem__", 4, argv[2]));
|
25547
|
+
}
|
25548
|
+
arg4 = ptr;
|
25549
|
+
}
|
25550
|
+
{
|
25551
|
+
try {
|
25552
|
+
try {
|
25553
|
+
result = (VALUE)std_vector_Sl_bool_Sg____setitem____SWIG_1(arg1,arg2,arg3,(std::vector< bool,std::allocator< bool > > const &)*arg4);
|
22615
25554
|
}
|
22616
25555
|
catch(std::invalid_argument &_e) {
|
22617
25556
|
SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
|
@@ -27752,10 +30691,10 @@ fail:
|
|
27752
30691
|
SWIGINTERN VALUE
|
27753
30692
|
_wrap_ModVars_name_set(int argc, VALUE *argv, VALUE self) {
|
27754
30693
|
ModVars *arg1 = (ModVars *) 0 ;
|
27755
|
-
vector< string > arg2 ;
|
30694
|
+
std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
|
27756
30695
|
void *argp1 = 0 ;
|
27757
30696
|
int res1 = 0 ;
|
27758
|
-
void *argp2 ;
|
30697
|
+
void *argp2 = 0 ;
|
27759
30698
|
int res2 = 0 ;
|
27760
30699
|
|
27761
30700
|
if ((argc < 1) || (argc > 1)) {
|
@@ -27766,18 +30705,12 @@ _wrap_ModVars_name_set(int argc, VALUE *argv, VALUE self) {
|
|
27766
30705
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","name", 1, self ));
|
27767
30706
|
}
|
27768
30707
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
27769
|
-
|
27770
|
-
|
27771
|
-
|
27772
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "vector< string >","name", 2, argv[0] ));
|
27773
|
-
}
|
27774
|
-
if (!argp2) {
|
27775
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "vector< string >","name", 2, argv[0]));
|
27776
|
-
} else {
|
27777
|
-
arg2 = *(reinterpret_cast< vector< string > * >(argp2));
|
27778
|
-
}
|
30708
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
|
30709
|
+
if (!SWIG_IsOK(res2)) {
|
30710
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< std::string,std::allocator< std::string > > *","name", 2, argv[0] ));
|
27779
30711
|
}
|
27780
|
-
|
30712
|
+
arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
|
30713
|
+
if (arg1) (arg1)->name = *arg2;
|
27781
30714
|
return Qnil;
|
27782
30715
|
fail:
|
27783
30716
|
return Qnil;
|
@@ -27789,7 +30722,7 @@ _wrap_ModVars_name_get(int argc, VALUE *argv, VALUE self) {
|
|
27789
30722
|
ModVars *arg1 = (ModVars *) 0 ;
|
27790
30723
|
void *argp1 = 0 ;
|
27791
30724
|
int res1 = 0 ;
|
27792
|
-
vector< string > result;
|
30725
|
+
std::vector< std::string,std::allocator< std::string > > *result = 0 ;
|
27793
30726
|
VALUE vresult = Qnil;
|
27794
30727
|
|
27795
30728
|
if ((argc < 0) || (argc > 0)) {
|
@@ -27800,8 +30733,8 @@ _wrap_ModVars_name_get(int argc, VALUE *argv, VALUE self) {
|
|
27800
30733
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","name", 1, self ));
|
27801
30734
|
}
|
27802
30735
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
27803
|
-
result =
|
27804
|
-
vresult = SWIG_NewPointerObj((
|
30736
|
+
result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->name);
|
30737
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 | 0 );
|
27805
30738
|
return vresult;
|
27806
30739
|
fail:
|
27807
30740
|
return Qnil;
|
@@ -27811,10 +30744,10 @@ fail:
|
|
27811
30744
|
SWIGINTERN VALUE
|
27812
30745
|
_wrap_ModVars_obj_set(int argc, VALUE *argv, VALUE self) {
|
27813
30746
|
ModVars *arg1 = (ModVars *) 0 ;
|
27814
|
-
vector< double > arg2 ;
|
30747
|
+
std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
|
27815
30748
|
void *argp1 = 0 ;
|
27816
30749
|
int res1 = 0 ;
|
27817
|
-
void *argp2 ;
|
30750
|
+
void *argp2 = 0 ;
|
27818
30751
|
int res2 = 0 ;
|
27819
30752
|
|
27820
30753
|
if ((argc < 1) || (argc > 1)) {
|
@@ -27825,18 +30758,12 @@ _wrap_ModVars_obj_set(int argc, VALUE *argv, VALUE self) {
|
|
27825
30758
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","obj", 1, self ));
|
27826
30759
|
}
|
27827
30760
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
27828
|
-
|
27829
|
-
|
27830
|
-
|
27831
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "vector< double >","obj", 2, argv[0] ));
|
27832
|
-
}
|
27833
|
-
if (!argp2) {
|
27834
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "vector< double >","obj", 2, argv[0]));
|
27835
|
-
} else {
|
27836
|
-
arg2 = *(reinterpret_cast< vector< double > * >(argp2));
|
27837
|
-
}
|
30761
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
|
30762
|
+
if (!SWIG_IsOK(res2)) {
|
30763
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< double,std::allocator< double > > *","obj", 2, argv[0] ));
|
27838
30764
|
}
|
27839
|
-
|
30765
|
+
arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
|
30766
|
+
if (arg1) (arg1)->obj = *arg2;
|
27840
30767
|
return Qnil;
|
27841
30768
|
fail:
|
27842
30769
|
return Qnil;
|
@@ -27848,7 +30775,7 @@ _wrap_ModVars_obj_get(int argc, VALUE *argv, VALUE self) {
|
|
27848
30775
|
ModVars *arg1 = (ModVars *) 0 ;
|
27849
30776
|
void *argp1 = 0 ;
|
27850
30777
|
int res1 = 0 ;
|
27851
|
-
vector< double > result;
|
30778
|
+
std::vector< double,std::allocator< double > > *result = 0 ;
|
27852
30779
|
VALUE vresult = Qnil;
|
27853
30780
|
|
27854
30781
|
if ((argc < 0) || (argc > 0)) {
|
@@ -27859,8 +30786,8 @@ _wrap_ModVars_obj_get(int argc, VALUE *argv, VALUE self) {
|
|
27859
30786
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","obj", 1, self ));
|
27860
30787
|
}
|
27861
30788
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
27862
|
-
result =
|
27863
|
-
vresult = SWIG_NewPointerObj((
|
30789
|
+
result = (std::vector< double,std::allocator< double > > *)& ((arg1)->obj);
|
30790
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
|
27864
30791
|
return vresult;
|
27865
30792
|
fail:
|
27866
30793
|
return Qnil;
|
@@ -27870,10 +30797,10 @@ fail:
|
|
27870
30797
|
SWIGINTERN VALUE
|
27871
30798
|
_wrap_ModVars_type_set(int argc, VALUE *argv, VALUE self) {
|
27872
30799
|
ModVars *arg1 = (ModVars *) 0 ;
|
27873
|
-
vector< char > arg2 ;
|
30800
|
+
std::vector< char,std::allocator< char > > *arg2 = (std::vector< char,std::allocator< char > > *) 0 ;
|
27874
30801
|
void *argp1 = 0 ;
|
27875
30802
|
int res1 = 0 ;
|
27876
|
-
void *argp2 ;
|
30803
|
+
void *argp2 = 0 ;
|
27877
30804
|
int res2 = 0 ;
|
27878
30805
|
|
27879
30806
|
if ((argc < 1) || (argc > 1)) {
|
@@ -27884,18 +30811,12 @@ _wrap_ModVars_type_set(int argc, VALUE *argv, VALUE self) {
|
|
27884
30811
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","type", 1, self ));
|
27885
30812
|
}
|
27886
30813
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
27887
|
-
|
27888
|
-
|
27889
|
-
|
27890
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "vector< char >","type", 2, argv[0] ));
|
27891
|
-
}
|
27892
|
-
if (!argp2) {
|
27893
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "vector< char >","type", 2, argv[0]));
|
27894
|
-
} else {
|
27895
|
-
arg2 = *(reinterpret_cast< vector< char > * >(argp2));
|
27896
|
-
}
|
30814
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 );
|
30815
|
+
if (!SWIG_IsOK(res2)) {
|
30816
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< char,std::allocator< char > > *","type", 2, argv[0] ));
|
27897
30817
|
}
|
27898
|
-
|
30818
|
+
arg2 = reinterpret_cast< std::vector< char,std::allocator< char > > * >(argp2);
|
30819
|
+
if (arg1) (arg1)->type = *arg2;
|
27899
30820
|
return Qnil;
|
27900
30821
|
fail:
|
27901
30822
|
return Qnil;
|
@@ -27907,7 +30828,7 @@ _wrap_ModVars_type_get(int argc, VALUE *argv, VALUE self) {
|
|
27907
30828
|
ModVars *arg1 = (ModVars *) 0 ;
|
27908
30829
|
void *argp1 = 0 ;
|
27909
30830
|
int res1 = 0 ;
|
27910
|
-
vector< char > result;
|
30831
|
+
std::vector< char,std::allocator< char > > *result = 0 ;
|
27911
30832
|
VALUE vresult = Qnil;
|
27912
30833
|
|
27913
30834
|
if ((argc < 0) || (argc > 0)) {
|
@@ -27918,8 +30839,8 @@ _wrap_ModVars_type_get(int argc, VALUE *argv, VALUE self) {
|
|
27918
30839
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","type", 1, self ));
|
27919
30840
|
}
|
27920
30841
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
27921
|
-
result =
|
27922
|
-
vresult = SWIG_NewPointerObj((
|
30842
|
+
result = (std::vector< char,std::allocator< char > > *)& ((arg1)->type);
|
30843
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t, 0 | 0 );
|
27923
30844
|
return vresult;
|
27924
30845
|
fail:
|
27925
30846
|
return Qnil;
|
@@ -27988,10 +30909,10 @@ fail:
|
|
27988
30909
|
SWIGINTERN VALUE
|
27989
30910
|
_wrap_ModVars_ub_set(int argc, VALUE *argv, VALUE self) {
|
27990
30911
|
ModVars *arg1 = (ModVars *) 0 ;
|
27991
|
-
vector< double > arg2 ;
|
30912
|
+
std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
|
27992
30913
|
void *argp1 = 0 ;
|
27993
30914
|
int res1 = 0 ;
|
27994
|
-
void *argp2 ;
|
30915
|
+
void *argp2 = 0 ;
|
27995
30916
|
int res2 = 0 ;
|
27996
30917
|
|
27997
30918
|
if ((argc < 1) || (argc > 1)) {
|
@@ -28002,18 +30923,12 @@ _wrap_ModVars_ub_set(int argc, VALUE *argv, VALUE self) {
|
|
28002
30923
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","ub", 1, self ));
|
28003
30924
|
}
|
28004
30925
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
28005
|
-
|
28006
|
-
|
28007
|
-
|
28008
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "vector< double >","ub", 2, argv[0] ));
|
28009
|
-
}
|
28010
|
-
if (!argp2) {
|
28011
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "vector< double >","ub", 2, argv[0]));
|
28012
|
-
} else {
|
28013
|
-
arg2 = *(reinterpret_cast< vector< double > * >(argp2));
|
28014
|
-
}
|
30926
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
|
30927
|
+
if (!SWIG_IsOK(res2)) {
|
30928
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< double,std::allocator< double > > *","ub", 2, argv[0] ));
|
28015
30929
|
}
|
28016
|
-
|
30930
|
+
arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
|
30931
|
+
if (arg1) (arg1)->ub = *arg2;
|
28017
30932
|
return Qnil;
|
28018
30933
|
fail:
|
28019
30934
|
return Qnil;
|
@@ -28025,7 +30940,7 @@ _wrap_ModVars_ub_get(int argc, VALUE *argv, VALUE self) {
|
|
28025
30940
|
ModVars *arg1 = (ModVars *) 0 ;
|
28026
30941
|
void *argp1 = 0 ;
|
28027
30942
|
int res1 = 0 ;
|
28028
|
-
vector< double > result;
|
30943
|
+
std::vector< double,std::allocator< double > > *result = 0 ;
|
28029
30944
|
VALUE vresult = Qnil;
|
28030
30945
|
|
28031
30946
|
if ((argc < 0) || (argc > 0)) {
|
@@ -28036,8 +30951,8 @@ _wrap_ModVars_ub_get(int argc, VALUE *argv, VALUE self) {
|
|
28036
30951
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","ub", 1, self ));
|
28037
30952
|
}
|
28038
30953
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
28039
|
-
result =
|
28040
|
-
vresult = SWIG_NewPointerObj((
|
30954
|
+
result = (std::vector< double,std::allocator< double > > *)& ((arg1)->ub);
|
30955
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
|
28041
30956
|
return vresult;
|
28042
30957
|
fail:
|
28043
30958
|
return Qnil;
|
@@ -28047,10 +30962,10 @@ fail:
|
|
28047
30962
|
SWIGINTERN VALUE
|
28048
30963
|
_wrap_ModVars_lb_set(int argc, VALUE *argv, VALUE self) {
|
28049
30964
|
ModVars *arg1 = (ModVars *) 0 ;
|
28050
|
-
vector< double > arg2 ;
|
30965
|
+
std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
|
28051
30966
|
void *argp1 = 0 ;
|
28052
30967
|
int res1 = 0 ;
|
28053
|
-
void *argp2 ;
|
30968
|
+
void *argp2 = 0 ;
|
28054
30969
|
int res2 = 0 ;
|
28055
30970
|
|
28056
30971
|
if ((argc < 1) || (argc > 1)) {
|
@@ -28061,18 +30976,12 @@ _wrap_ModVars_lb_set(int argc, VALUE *argv, VALUE self) {
|
|
28061
30976
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","lb", 1, self ));
|
28062
30977
|
}
|
28063
30978
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
28064
|
-
|
28065
|
-
|
28066
|
-
|
28067
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "vector< double >","lb", 2, argv[0] ));
|
28068
|
-
}
|
28069
|
-
if (!argp2) {
|
28070
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "vector< double >","lb", 2, argv[0]));
|
28071
|
-
} else {
|
28072
|
-
arg2 = *(reinterpret_cast< vector< double > * >(argp2));
|
28073
|
-
}
|
30979
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
|
30980
|
+
if (!SWIG_IsOK(res2)) {
|
30981
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< double,std::allocator< double > > *","lb", 2, argv[0] ));
|
28074
30982
|
}
|
28075
|
-
|
30983
|
+
arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
|
30984
|
+
if (arg1) (arg1)->lb = *arg2;
|
28076
30985
|
return Qnil;
|
28077
30986
|
fail:
|
28078
30987
|
return Qnil;
|
@@ -28084,7 +30993,7 @@ _wrap_ModVars_lb_get(int argc, VALUE *argv, VALUE self) {
|
|
28084
30993
|
ModVars *arg1 = (ModVars *) 0 ;
|
28085
30994
|
void *argp1 = 0 ;
|
28086
30995
|
int res1 = 0 ;
|
28087
|
-
vector< double > result;
|
30996
|
+
std::vector< double,std::allocator< double > > *result = 0 ;
|
28088
30997
|
VALUE vresult = Qnil;
|
28089
30998
|
|
28090
30999
|
if ((argc < 0) || (argc > 0)) {
|
@@ -28095,8 +31004,8 @@ _wrap_ModVars_lb_get(int argc, VALUE *argv, VALUE self) {
|
|
28095
31004
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","lb", 1, self ));
|
28096
31005
|
}
|
28097
31006
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
28098
|
-
result =
|
28099
|
-
vresult = SWIG_NewPointerObj((
|
31007
|
+
result = (std::vector< double,std::allocator< double > > *)& ((arg1)->lb);
|
31008
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
|
28100
31009
|
return vresult;
|
28101
31010
|
fail:
|
28102
31011
|
return Qnil;
|
@@ -28159,10 +31068,10 @@ fail:
|
|
28159
31068
|
SWIGINTERN VALUE
|
28160
31069
|
_wrap_ModVars_rc_set(int argc, VALUE *argv, VALUE self) {
|
28161
31070
|
ModVars *arg1 = (ModVars *) 0 ;
|
28162
|
-
vector< double > arg2 ;
|
31071
|
+
std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
|
28163
31072
|
void *argp1 = 0 ;
|
28164
31073
|
int res1 = 0 ;
|
28165
|
-
void *argp2 ;
|
31074
|
+
void *argp2 = 0 ;
|
28166
31075
|
int res2 = 0 ;
|
28167
31076
|
|
28168
31077
|
if ((argc < 1) || (argc > 1)) {
|
@@ -28173,18 +31082,12 @@ _wrap_ModVars_rc_set(int argc, VALUE *argv, VALUE self) {
|
|
28173
31082
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","rc", 1, self ));
|
28174
31083
|
}
|
28175
31084
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
28176
|
-
|
28177
|
-
|
28178
|
-
|
28179
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "vector< double >","rc", 2, argv[0] ));
|
28180
|
-
}
|
28181
|
-
if (!argp2) {
|
28182
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "vector< double >","rc", 2, argv[0]));
|
28183
|
-
} else {
|
28184
|
-
arg2 = *(reinterpret_cast< vector< double > * >(argp2));
|
28185
|
-
}
|
31085
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
|
31086
|
+
if (!SWIG_IsOK(res2)) {
|
31087
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< double,std::allocator< double > > *","rc", 2, argv[0] ));
|
28186
31088
|
}
|
28187
|
-
|
31089
|
+
arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
|
31090
|
+
if (arg1) (arg1)->rc = *arg2;
|
28188
31091
|
return Qnil;
|
28189
31092
|
fail:
|
28190
31093
|
return Qnil;
|
@@ -28196,7 +31099,7 @@ _wrap_ModVars_rc_get(int argc, VALUE *argv, VALUE self) {
|
|
28196
31099
|
ModVars *arg1 = (ModVars *) 0 ;
|
28197
31100
|
void *argp1 = 0 ;
|
28198
31101
|
int res1 = 0 ;
|
28199
|
-
vector< double > result;
|
31102
|
+
std::vector< double,std::allocator< double > > *result = 0 ;
|
28200
31103
|
VALUE vresult = Qnil;
|
28201
31104
|
|
28202
31105
|
if ((argc < 0) || (argc > 0)) {
|
@@ -28207,8 +31110,8 @@ _wrap_ModVars_rc_get(int argc, VALUE *argv, VALUE self) {
|
|
28207
31110
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","rc", 1, self ));
|
28208
31111
|
}
|
28209
31112
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
28210
|
-
result =
|
28211
|
-
vresult = SWIG_NewPointerObj((
|
31113
|
+
result = (std::vector< double,std::allocator< double > > *)& ((arg1)->rc);
|
31114
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
|
28212
31115
|
return vresult;
|
28213
31116
|
fail:
|
28214
31117
|
return Qnil;
|
@@ -28218,10 +31121,10 @@ fail:
|
|
28218
31121
|
SWIGINTERN VALUE
|
28219
31122
|
_wrap_ModVars_qobj_set(int argc, VALUE *argv, VALUE self) {
|
28220
31123
|
ModVars *arg1 = (ModVars *) 0 ;
|
28221
|
-
vector< double > arg2 ;
|
31124
|
+
std::vector< double,std::allocator< double > > *arg2 = (std::vector< double,std::allocator< double > > *) 0 ;
|
28222
31125
|
void *argp1 = 0 ;
|
28223
31126
|
int res1 = 0 ;
|
28224
|
-
void *argp2 ;
|
31127
|
+
void *argp2 = 0 ;
|
28225
31128
|
int res2 = 0 ;
|
28226
31129
|
|
28227
31130
|
if ((argc < 1) || (argc > 1)) {
|
@@ -28232,18 +31135,12 @@ _wrap_ModVars_qobj_set(int argc, VALUE *argv, VALUE self) {
|
|
28232
31135
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","qobj", 1, self ));
|
28233
31136
|
}
|
28234
31137
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
28235
|
-
|
28236
|
-
|
28237
|
-
|
28238
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "vector< double >","qobj", 2, argv[0] ));
|
28239
|
-
}
|
28240
|
-
if (!argp2) {
|
28241
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "vector< double >","qobj", 2, argv[0]));
|
28242
|
-
} else {
|
28243
|
-
arg2 = *(reinterpret_cast< vector< double > * >(argp2));
|
28244
|
-
}
|
31138
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
|
31139
|
+
if (!SWIG_IsOK(res2)) {
|
31140
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< double,std::allocator< double > > *","qobj", 2, argv[0] ));
|
28245
31141
|
}
|
28246
|
-
|
31142
|
+
arg2 = reinterpret_cast< std::vector< double,std::allocator< double > > * >(argp2);
|
31143
|
+
if (arg1) (arg1)->qobj = *arg2;
|
28247
31144
|
return Qnil;
|
28248
31145
|
fail:
|
28249
31146
|
return Qnil;
|
@@ -28255,7 +31152,7 @@ _wrap_ModVars_qobj_get(int argc, VALUE *argv, VALUE self) {
|
|
28255
31152
|
ModVars *arg1 = (ModVars *) 0 ;
|
28256
31153
|
void *argp1 = 0 ;
|
28257
31154
|
int res1 = 0 ;
|
28258
|
-
vector< double > result;
|
31155
|
+
std::vector< double,std::allocator< double > > *result = 0 ;
|
28259
31156
|
VALUE vresult = Qnil;
|
28260
31157
|
|
28261
31158
|
if ((argc < 0) || (argc > 0)) {
|
@@ -28266,8 +31163,8 @@ _wrap_ModVars_qobj_get(int argc, VALUE *argv, VALUE self) {
|
|
28266
31163
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","qobj", 1, self ));
|
28267
31164
|
}
|
28268
31165
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
28269
|
-
result =
|
28270
|
-
vresult = SWIG_NewPointerObj((
|
31166
|
+
result = (std::vector< double,std::allocator< double > > *)& ((arg1)->qobj);
|
31167
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 | 0 );
|
28271
31168
|
return vresult;
|
28272
31169
|
fail:
|
28273
31170
|
return Qnil;
|
@@ -28277,10 +31174,10 @@ fail:
|
|
28277
31174
|
SWIGINTERN VALUE
|
28278
31175
|
_wrap_ModVars_qi_set(int argc, VALUE *argv, VALUE self) {
|
28279
31176
|
ModVars *arg1 = (ModVars *) 0 ;
|
28280
|
-
vector< long > arg2 ;
|
31177
|
+
std::vector< long,std::allocator< long > > *arg2 = (std::vector< long,std::allocator< long > > *) 0 ;
|
28281
31178
|
void *argp1 = 0 ;
|
28282
31179
|
int res1 = 0 ;
|
28283
|
-
void *argp2 ;
|
31180
|
+
void *argp2 = 0 ;
|
28284
31181
|
int res2 = 0 ;
|
28285
31182
|
|
28286
31183
|
if ((argc < 1) || (argc > 1)) {
|
@@ -28291,18 +31188,12 @@ _wrap_ModVars_qi_set(int argc, VALUE *argv, VALUE self) {
|
|
28291
31188
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","qi", 1, self ));
|
28292
31189
|
}
|
28293
31190
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
28294
|
-
|
28295
|
-
|
28296
|
-
|
28297
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "vector< long >","qi", 2, argv[0] ));
|
28298
|
-
}
|
28299
|
-
if (!argp2) {
|
28300
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "vector< long >","qi", 2, argv[0]));
|
28301
|
-
} else {
|
28302
|
-
arg2 = *(reinterpret_cast< vector< long > * >(argp2));
|
28303
|
-
}
|
31191
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 );
|
31192
|
+
if (!SWIG_IsOK(res2)) {
|
31193
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< long,std::allocator< long > > *","qi", 2, argv[0] ));
|
28304
31194
|
}
|
28305
|
-
|
31195
|
+
arg2 = reinterpret_cast< std::vector< long,std::allocator< long > > * >(argp2);
|
31196
|
+
if (arg1) (arg1)->qi = *arg2;
|
28306
31197
|
return Qnil;
|
28307
31198
|
fail:
|
28308
31199
|
return Qnil;
|
@@ -28314,7 +31205,7 @@ _wrap_ModVars_qi_get(int argc, VALUE *argv, VALUE self) {
|
|
28314
31205
|
ModVars *arg1 = (ModVars *) 0 ;
|
28315
31206
|
void *argp1 = 0 ;
|
28316
31207
|
int res1 = 0 ;
|
28317
|
-
vector< long > result;
|
31208
|
+
std::vector< long,std::allocator< long > > *result = 0 ;
|
28318
31209
|
VALUE vresult = Qnil;
|
28319
31210
|
|
28320
31211
|
if ((argc < 0) || (argc > 0)) {
|
@@ -28325,8 +31216,8 @@ _wrap_ModVars_qi_get(int argc, VALUE *argv, VALUE self) {
|
|
28325
31216
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","qi", 1, self ));
|
28326
31217
|
}
|
28327
31218
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
28328
|
-
result =
|
28329
|
-
vresult = SWIG_NewPointerObj((
|
31219
|
+
result = (std::vector< long,std::allocator< long > > *)& ((arg1)->qi);
|
31220
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 );
|
28330
31221
|
return vresult;
|
28331
31222
|
fail:
|
28332
31223
|
return Qnil;
|
@@ -28336,10 +31227,10 @@ fail:
|
|
28336
31227
|
SWIGINTERN VALUE
|
28337
31228
|
_wrap_ModVars_qj_set(int argc, VALUE *argv, VALUE self) {
|
28338
31229
|
ModVars *arg1 = (ModVars *) 0 ;
|
28339
|
-
vector< long > arg2 ;
|
31230
|
+
std::vector< long,std::allocator< long > > *arg2 = (std::vector< long,std::allocator< long > > *) 0 ;
|
28340
31231
|
void *argp1 = 0 ;
|
28341
31232
|
int res1 = 0 ;
|
28342
|
-
void *argp2 ;
|
31233
|
+
void *argp2 = 0 ;
|
28343
31234
|
int res2 = 0 ;
|
28344
31235
|
|
28345
31236
|
if ((argc < 1) || (argc > 1)) {
|
@@ -28350,18 +31241,12 @@ _wrap_ModVars_qj_set(int argc, VALUE *argv, VALUE self) {
|
|
28350
31241
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","qj", 1, self ));
|
28351
31242
|
}
|
28352
31243
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
28353
|
-
|
28354
|
-
|
28355
|
-
|
28356
|
-
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "vector< long >","qj", 2, argv[0] ));
|
28357
|
-
}
|
28358
|
-
if (!argp2) {
|
28359
|
-
SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "vector< long >","qj", 2, argv[0]));
|
28360
|
-
} else {
|
28361
|
-
arg2 = *(reinterpret_cast< vector< long > * >(argp2));
|
28362
|
-
}
|
31244
|
+
res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 );
|
31245
|
+
if (!SWIG_IsOK(res2)) {
|
31246
|
+
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< long,std::allocator< long > > *","qj", 2, argv[0] ));
|
28363
31247
|
}
|
28364
|
-
|
31248
|
+
arg2 = reinterpret_cast< std::vector< long,std::allocator< long > > * >(argp2);
|
31249
|
+
if (arg1) (arg1)->qj = *arg2;
|
28365
31250
|
return Qnil;
|
28366
31251
|
fail:
|
28367
31252
|
return Qnil;
|
@@ -28373,7 +31258,7 @@ _wrap_ModVars_qj_get(int argc, VALUE *argv, VALUE self) {
|
|
28373
31258
|
ModVars *arg1 = (ModVars *) 0 ;
|
28374
31259
|
void *argp1 = 0 ;
|
28375
31260
|
int res1 = 0 ;
|
28376
|
-
vector< long > result;
|
31261
|
+
std::vector< long,std::allocator< long > > *result = 0 ;
|
28377
31262
|
VALUE vresult = Qnil;
|
28378
31263
|
|
28379
31264
|
if ((argc < 0) || (argc > 0)) {
|
@@ -28384,8 +31269,8 @@ _wrap_ModVars_qj_get(int argc, VALUE *argv, VALUE self) {
|
|
28384
31269
|
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ModVars *","qj", 1, self ));
|
28385
31270
|
}
|
28386
31271
|
arg1 = reinterpret_cast< ModVars * >(argp1);
|
28387
|
-
result =
|
28388
|
-
vresult = SWIG_NewPointerObj((
|
31272
|
+
result = (std::vector< long,std::allocator< long > > *)& ((arg1)->qj);
|
31273
|
+
vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t, 0 | 0 );
|
28389
31274
|
return vresult;
|
28390
31275
|
fail:
|
28391
31276
|
return Qnil;
|
@@ -42150,25 +45035,24 @@ static swig_type_info _swigt__p_std__allocatorT_int_t = {"_p_std__allocatorT_int
|
|
42150
45035
|
static swig_type_info _swigt__p_std__allocatorT_long_t = {"_p_std__allocatorT_long_t", "std::vector< long >::allocator_type *|std::allocator< long > *", 0, 0, (void*)0, 0};
|
42151
45036
|
static swig_type_info _swigt__p_std__allocatorT_size_t_t = {"_p_std__allocatorT_size_t_t", "std::vector< size_t >::allocator_type *|std::allocator< size_t > *", 0, 0, (void*)0, 0};
|
42152
45037
|
static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__allocatorT_std__string_t", "std::vector< std::string >::allocator_type *|std::allocator< std::string > *", 0, 0, (void*)0, 0};
|
45038
|
+
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t = {"_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t", "std::vector< std::vector< double > >::allocator_type *|std::allocator< std::vector< double,std::allocator< double > > > *", 0, 0, (void*)0, 0};
|
42153
45039
|
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t = {"_p_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t", "std::vector< std::vector< size_t > >::allocator_type *|std::allocator< std::vector< size_t,std::allocator< size_t > > > *", 0, 0, (void*)0, 0};
|
42154
45040
|
static swig_type_info _swigt__p_std__vectorT_HyperGen_std__allocatorT_HyperGen_t_t = {"_p_std__vectorT_HyperGen_std__allocatorT_HyperGen_t_t", "std::vector< HyperGen,std::allocator< HyperGen > > *|std::vector< HyperGen > *", 0, 0, (void*)0, 0};
|
42155
45041
|
static swig_type_info _swigt__p_std__vectorT_ModConsts_std__allocatorT_ModConsts_t_t = {"_p_std__vectorT_ModConsts_std__allocatorT_ModConsts_t_t", "std::vector< ModConsts,std::allocator< ModConsts > > *", 0, 0, (void*)0, 0};
|
42156
45042
|
static swig_type_info _swigt__p_std__vectorT_bool_std__allocatorT_bool_t_t = {"_p_std__vectorT_bool_std__allocatorT_bool_t_t", "std::vector< bool,std::allocator< bool > > *|std::vector< bool > *", 0, 0, (void*)0, 0};
|
45043
|
+
static swig_type_info _swigt__p_std__vectorT_char_std__allocatorT_char_t_t = {"_p_std__vectorT_char_std__allocatorT_char_t_t", "std::vector< char,std::allocator< char > > *", 0, 0, (void*)0, 0};
|
42157
45044
|
static swig_type_info _swigt__p_std__vectorT_double_std__allocatorT_double_t_t = {"_p_std__vectorT_double_std__allocatorT_double_t_t", "std::vector< double,std::allocator< double > > *|std::vector< double > *", 0, 0, (void*)0, 0};
|
42158
45045
|
static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|std::vector< int > *", 0, 0, (void*)0, 0};
|
42159
45046
|
static swig_type_info _swigt__p_std__vectorT_long_std__allocatorT_long_t_t = {"_p_std__vectorT_long_std__allocatorT_long_t_t", "std::vector< long,std::allocator< long > > *|std::vector< long > *", 0, 0, (void*)0, 0};
|
42160
45047
|
static swig_type_info _swigt__p_std__vectorT_size_t_std__allocatorT_size_t_t_t = {"_p_std__vectorT_size_t_std__allocatorT_size_t_t_t", "std::vector< size_t,std::allocator< size_t > > *|std::vector< size_t > *", 0, 0, (void*)0, 0};
|
42161
45048
|
static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "std::vector< std::string,std::allocator< std::string > > *|std::vector< std::string > *", 0, 0, (void*)0, 0};
|
45049
|
+
static swig_type_info _swigt__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t = {"_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t", "std::vector< std::vector< double > > *|std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *|std::vector< std::vector< double,std::allocator< double > > > *", 0, 0, (void*)0, 0};
|
42162
45050
|
static swig_type_info _swigt__p_std__vectorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t_t = {"_p_std__vectorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t_t", "std::vector< std::vector< size_t > > *|std::vector< std::vector< size_t,std::allocator< size_t > >,std::allocator< std::vector< size_t,std::allocator< size_t > > > > *|std::vector< std::vector< size_t,std::allocator< size_t > > > *", 0, 0, (void*)0, 0};
|
42163
45051
|
static swig_type_info _swigt__p_string = {"_p_string", "string *", 0, 0, (void*)0, 0};
|
42164
45052
|
static swig_type_info _swigt__p_swig__ConstIterator = {"_p_swig__ConstIterator", "swig::ConstIterator *", 0, 0, (void*)0, 0};
|
42165
45053
|
static swig_type_info _swigt__p_swig__GC_VALUE = {"_p_swig__GC_VALUE", "swig::GC_VALUE *", 0, 0, (void*)0, 0};
|
42166
45054
|
static swig_type_info _swigt__p_swig__Iterator = {"_p_swig__Iterator", "swig::Iterator *", 0, 0, (void*)0, 0};
|
42167
45055
|
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
|
42168
|
-
static swig_type_info _swigt__p_vectorT_char_t = {"_p_vectorT_char_t", "vector< char > *", 0, 0, (void*)0, 0};
|
42169
|
-
static swig_type_info _swigt__p_vectorT_double_t = {"_p_vectorT_double_t", "vector< double > *", 0, 0, (void*)0, 0};
|
42170
|
-
static swig_type_info _swigt__p_vectorT_long_t = {"_p_vectorT_long_t", "vector< long > *", 0, 0, (void*)0, 0};
|
42171
|
-
static swig_type_info _swigt__p_vectorT_string_t = {"_p_vectorT_string_t", "vector< string > *", 0, 0, (void*)0, 0};
|
42172
45056
|
static swig_type_info _swigt__p_void = {"_p_void", "VALUE|void *", 0, 0, (void*)0, 0};
|
42173
45057
|
|
42174
45058
|
static swig_type_info *swig_type_initial[] = {
|
@@ -42202,25 +45086,24 @@ static swig_type_info *swig_type_initial[] = {
|
|
42202
45086
|
&_swigt__p_std__allocatorT_long_t,
|
42203
45087
|
&_swigt__p_std__allocatorT_size_t_t,
|
42204
45088
|
&_swigt__p_std__allocatorT_std__string_t,
|
45089
|
+
&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
|
42205
45090
|
&_swigt__p_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t,
|
42206
45091
|
&_swigt__p_std__vectorT_HyperGen_std__allocatorT_HyperGen_t_t,
|
42207
45092
|
&_swigt__p_std__vectorT_ModConsts_std__allocatorT_ModConsts_t_t,
|
42208
45093
|
&_swigt__p_std__vectorT_bool_std__allocatorT_bool_t_t,
|
45094
|
+
&_swigt__p_std__vectorT_char_std__allocatorT_char_t_t,
|
42209
45095
|
&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t,
|
42210
45096
|
&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
|
42211
45097
|
&_swigt__p_std__vectorT_long_std__allocatorT_long_t_t,
|
42212
45098
|
&_swigt__p_std__vectorT_size_t_std__allocatorT_size_t_t_t,
|
42213
45099
|
&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
|
45100
|
+
&_swigt__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,
|
42214
45101
|
&_swigt__p_std__vectorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t_t,
|
42215
45102
|
&_swigt__p_string,
|
42216
45103
|
&_swigt__p_swig__ConstIterator,
|
42217
45104
|
&_swigt__p_swig__GC_VALUE,
|
42218
45105
|
&_swigt__p_swig__Iterator,
|
42219
45106
|
&_swigt__p_value_type,
|
42220
|
-
&_swigt__p_vectorT_char_t,
|
42221
|
-
&_swigt__p_vectorT_double_t,
|
42222
|
-
&_swigt__p_vectorT_long_t,
|
42223
|
-
&_swigt__p_vectorT_string_t,
|
42224
45107
|
&_swigt__p_void,
|
42225
45108
|
};
|
42226
45109
|
|
@@ -42254,25 +45137,24 @@ static swig_cast_info _swigc__p_std__allocatorT_int_t[] = { {&_swigt__p_std__al
|
|
42254
45137
|
static swig_cast_info _swigc__p_std__allocatorT_long_t[] = { {&_swigt__p_std__allocatorT_long_t, 0, 0, 0},{0, 0, 0, 0}};
|
42255
45138
|
static swig_cast_info _swigc__p_std__allocatorT_size_t_t[] = { {&_swigt__p_std__allocatorT_size_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
42256
45139
|
static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = { {&_swigt__p_std__allocatorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
|
45140
|
+
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
42257
45141
|
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t[] = { {&_swigt__p_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
42258
45142
|
static swig_cast_info _swigc__p_std__vectorT_HyperGen_std__allocatorT_HyperGen_t_t[] = { {&_swigt__p_std__vectorT_HyperGen_std__allocatorT_HyperGen_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
42259
45143
|
static swig_cast_info _swigc__p_std__vectorT_ModConsts_std__allocatorT_ModConsts_t_t[] = { {&_swigt__p_std__vectorT_ModConsts_std__allocatorT_ModConsts_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
42260
45144
|
static swig_cast_info _swigc__p_std__vectorT_bool_std__allocatorT_bool_t_t[] = { {&_swigt__p_std__vectorT_bool_std__allocatorT_bool_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
45145
|
+
static swig_cast_info _swigc__p_std__vectorT_char_std__allocatorT_char_t_t[] = { {&_swigt__p_std__vectorT_char_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
42261
45146
|
static swig_cast_info _swigc__p_std__vectorT_double_std__allocatorT_double_t_t[] = { {&_swigt__p_std__vectorT_double_std__allocatorT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
42262
45147
|
static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = { {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
42263
45148
|
static swig_cast_info _swigc__p_std__vectorT_long_std__allocatorT_long_t_t[] = { {&_swigt__p_std__vectorT_long_std__allocatorT_long_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
42264
45149
|
static swig_cast_info _swigc__p_std__vectorT_size_t_std__allocatorT_size_t_t_t[] = { {&_swigt__p_std__vectorT_size_t_std__allocatorT_size_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
42265
45150
|
static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = { {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
45151
|
+
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t[] = { {&_swigt__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
42266
45152
|
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t_t[] = { {&_swigt__p_std__vectorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
|
42267
45153
|
static swig_cast_info _swigc__p_string[] = { {&_swigt__p_string, 0, 0, 0},{0, 0, 0, 0}};
|
42268
45154
|
static swig_cast_info _swigc__p_swig__ConstIterator[] = { {&_swigt__p_swig__ConstIterator, 0, 0, 0}, {&_swigt__p_swig__Iterator, _p_swig__IteratorTo_p_swig__ConstIterator, 0, 0},{0, 0, 0, 0}};
|
42269
45155
|
static swig_cast_info _swigc__p_swig__GC_VALUE[] = { {&_swigt__p_swig__GC_VALUE, 0, 0, 0},{0, 0, 0, 0}};
|
42270
45156
|
static swig_cast_info _swigc__p_swig__Iterator[] = { {&_swigt__p_swig__Iterator, 0, 0, 0},{0, 0, 0, 0}};
|
42271
45157
|
static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
|
42272
|
-
static swig_cast_info _swigc__p_vectorT_char_t[] = { {&_swigt__p_vectorT_char_t, 0, 0, 0},{0, 0, 0, 0}};
|
42273
|
-
static swig_cast_info _swigc__p_vectorT_double_t[] = { {&_swigt__p_vectorT_double_t, 0, 0, 0},{0, 0, 0, 0}};
|
42274
|
-
static swig_cast_info _swigc__p_vectorT_long_t[] = { {&_swigt__p_vectorT_long_t, 0, 0, 0},{0, 0, 0, 0}};
|
42275
|
-
static swig_cast_info _swigc__p_vectorT_string_t[] = { {&_swigt__p_vectorT_string_t, 0, 0, 0},{0, 0, 0, 0}};
|
42276
45158
|
static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
|
42277
45159
|
|
42278
45160
|
static swig_cast_info *swig_cast_initial[] = {
|
@@ -42306,25 +45188,24 @@ static swig_cast_info *swig_cast_initial[] = {
|
|
42306
45188
|
_swigc__p_std__allocatorT_long_t,
|
42307
45189
|
_swigc__p_std__allocatorT_size_t_t,
|
42308
45190
|
_swigc__p_std__allocatorT_std__string_t,
|
45191
|
+
_swigc__p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t,
|
42309
45192
|
_swigc__p_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t,
|
42310
45193
|
_swigc__p_std__vectorT_HyperGen_std__allocatorT_HyperGen_t_t,
|
42311
45194
|
_swigc__p_std__vectorT_ModConsts_std__allocatorT_ModConsts_t_t,
|
42312
45195
|
_swigc__p_std__vectorT_bool_std__allocatorT_bool_t_t,
|
45196
|
+
_swigc__p_std__vectorT_char_std__allocatorT_char_t_t,
|
42313
45197
|
_swigc__p_std__vectorT_double_std__allocatorT_double_t_t,
|
42314
45198
|
_swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
|
42315
45199
|
_swigc__p_std__vectorT_long_std__allocatorT_long_t_t,
|
42316
45200
|
_swigc__p_std__vectorT_size_t_std__allocatorT_size_t_t_t,
|
42317
45201
|
_swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
|
45202
|
+
_swigc__p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t,
|
42318
45203
|
_swigc__p_std__vectorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t_t,
|
42319
45204
|
_swigc__p_string,
|
42320
45205
|
_swigc__p_swig__ConstIterator,
|
42321
45206
|
_swigc__p_swig__GC_VALUE,
|
42322
45207
|
_swigc__p_swig__Iterator,
|
42323
45208
|
_swigc__p_value_type,
|
42324
|
-
_swigc__p_vectorT_char_t,
|
42325
|
-
_swigc__p_vectorT_double_t,
|
42326
|
-
_swigc__p_vectorT_long_t,
|
42327
|
-
_swigc__p_vectorT_string_t,
|
42328
45209
|
_swigc__p_void,
|
42329
45210
|
};
|
42330
45211
|
|
@@ -42862,6 +45743,52 @@ SWIGEXPORT void Init_Genmodel(void) {
|
|
42862
45743
|
SwigClassDoubleVector.destroy = (void (*)(void *)) free_std_vector_Sl_double_Sg_;
|
42863
45744
|
SwigClassDoubleVector.trackObjects = 0;
|
42864
45745
|
|
45746
|
+
SwigClassDoubleVector2d.klass = rb_define_class_under(mGenmodel, "DoubleVector2d", rb_cObject);
|
45747
|
+
SWIG_TypeClientData(SWIGTYPE_p_std__vectorT_std__vectorT_double_std__allocatorT_double_t_t_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t_t, (void *) &SwigClassDoubleVector2d);
|
45748
|
+
rb_include_module(SwigClassDoubleVector2d.klass, rb_eval_string("Enumerable"));
|
45749
|
+
rb_define_alloc_func(SwigClassDoubleVector2d.klass, _wrap_DoubleVector2d_allocate);
|
45750
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "initialize", VALUEFUNC(_wrap_new_DoubleVector2d), -1);
|
45751
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "dup", VALUEFUNC(_wrap_DoubleVector2d_dup), -1);
|
45752
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "inspect", VALUEFUNC(_wrap_DoubleVector2d_inspect), -1);
|
45753
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "to_a", VALUEFUNC(_wrap_DoubleVector2d_to_a), -1);
|
45754
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "to_s", VALUEFUNC(_wrap_DoubleVector2d_to_s), -1);
|
45755
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "slice", VALUEFUNC(_wrap_DoubleVector2d_slice), -1);
|
45756
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "each", VALUEFUNC(_wrap_DoubleVector2d_each), -1);
|
45757
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "select", VALUEFUNC(_wrap_DoubleVector2d_select), -1);
|
45758
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "delete_at", VALUEFUNC(_wrap_DoubleVector2d_delete_at), -1);
|
45759
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "__delete2__", VALUEFUNC(_wrap_DoubleVector2d___delete2__), -1);
|
45760
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "reject!", VALUEFUNC(_wrap_DoubleVector2d_rejectN___), -1);
|
45761
|
+
rb_define_alias(SwigClassDoubleVector2d.klass, "delete_if", "reject!");
|
45762
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "pop", VALUEFUNC(_wrap_DoubleVector2d_pop), -1);
|
45763
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "push", VALUEFUNC(_wrap_DoubleVector2d_push), -1);
|
45764
|
+
rb_define_alias(SwigClassDoubleVector2d.klass, "<<", "push");
|
45765
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "reject", VALUEFUNC(_wrap_DoubleVector2d_reject), -1);
|
45766
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "at", VALUEFUNC(_wrap_DoubleVector2d_at), -1);
|
45767
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "[]", VALUEFUNC(_wrap_DoubleVector2d___getitem__), -1);
|
45768
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "[]=", VALUEFUNC(_wrap_DoubleVector2d___setitem__), -1);
|
45769
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "shift", VALUEFUNC(_wrap_DoubleVector2d_shift), -1);
|
45770
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "unshift", VALUEFUNC(_wrap_DoubleVector2d_unshift), -1);
|
45771
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "empty?", VALUEFUNC(_wrap_DoubleVector2d_emptyq___), -1);
|
45772
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "size", VALUEFUNC(_wrap_DoubleVector2d_size), -1);
|
45773
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "clear", VALUEFUNC(_wrap_DoubleVector2d_clear), -1);
|
45774
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "swap", VALUEFUNC(_wrap_DoubleVector2d_swap), -1);
|
45775
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "get_allocator", VALUEFUNC(_wrap_DoubleVector2d_get_allocator), -1);
|
45776
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "begin", VALUEFUNC(_wrap_DoubleVector2d_begin), -1);
|
45777
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "end", VALUEFUNC(_wrap_DoubleVector2d_end), -1);
|
45778
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "rbegin", VALUEFUNC(_wrap_DoubleVector2d_rbegin), -1);
|
45779
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "rend", VALUEFUNC(_wrap_DoubleVector2d_rend), -1);
|
45780
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "erase", VALUEFUNC(_wrap_DoubleVector2d_erase), -1);
|
45781
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "front", VALUEFUNC(_wrap_DoubleVector2d_front), -1);
|
45782
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "back", VALUEFUNC(_wrap_DoubleVector2d_back), -1);
|
45783
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "assign", VALUEFUNC(_wrap_DoubleVector2d_assign), -1);
|
45784
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "resize", VALUEFUNC(_wrap_DoubleVector2d_resize), -1);
|
45785
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "insert", VALUEFUNC(_wrap_DoubleVector2d_insert), -1);
|
45786
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "reserve", VALUEFUNC(_wrap_DoubleVector2d_reserve), -1);
|
45787
|
+
rb_define_method(SwigClassDoubleVector2d.klass, "capacity", VALUEFUNC(_wrap_DoubleVector2d_capacity), -1);
|
45788
|
+
SwigClassDoubleVector2d.mark = 0;
|
45789
|
+
SwigClassDoubleVector2d.destroy = (void (*)(void *)) free_std_vector_Sl_std_vector_Sl_double_Sg__Sg_;
|
45790
|
+
SwigClassDoubleVector2d.trackObjects = 0;
|
45791
|
+
|
42865
45792
|
SwigClassBoolVector.klass = rb_define_class_under(mGenmodel, "BoolVector", rb_cObject);
|
42866
45793
|
SWIG_TypeClientData(SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, (void *) &SwigClassBoolVector);
|
42867
45794
|
rb_define_alloc_func(SwigClassBoolVector.klass, _wrap_BoolVector_allocate);
|