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.
Files changed (3) hide show
  1. checksums.yaml +4 -4
  2. data/ext/Genmodel/Genmodel.cpp +3338 -411
  3. metadata +1 -1
@@ -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 SWIGTYPE_p_std__allocatorT_std__vectorT_size_t_std__allocatorT_size_t_t_t_t swig_types[30]
1839
- #define SWIGTYPE_p_std__vectorT_HyperGen_std__allocatorT_HyperGen_t_t swig_types[31]
1840
- #define SWIGTYPE_p_std__vectorT_ModConsts_std__allocatorT_ModConsts_t_t swig_types[32]
1841
- #define SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t swig_types[33]
1842
- #define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[34]
1843
- #define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[35]
1844
- #define SWIGTYPE_p_std__vectorT_long_std__allocatorT_long_t_t swig_types[36]
1845
- #define SWIGTYPE_p_std__vectorT_size_t_std__allocatorT_size_t_t_t swig_types[37]
1846
- #define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[38]
1847
- #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[39]
1848
- #define SWIGTYPE_p_string swig_types[40]
1849
- #define SWIGTYPE_p_swig__ConstIterator swig_types[41]
1850
- #define SWIGTYPE_p_swig__GC_VALUE swig_types[42]
1851
- #define SWIGTYPE_p_swig__Iterator swig_types[43]
1852
- #define SWIGTYPE_p_value_type swig_types[44]
1853
- #define SWIGTYPE_p_vectorT_char_t swig_types[45]
1854
- #define SWIGTYPE_p_vectorT_double_t swig_types[46]
1855
- #define SWIGTYPE_p_vectorT_long_t swig_types[47]
1856
- #define SWIGTYPE_p_vectorT_string_t swig_types[48]
1857
- #define SWIGTYPE_p_void swig_types[49]
1858
- static swig_type_info *swig_types[51];
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 SwigClassBoolVector;
21951
+ static swig_class SwigClassDoubleVector2d;
21652
21952
 
21653
21953
 
21654
21954
  /*
21655
- Document-method: Genmodel::BoolVector.dup
21955
+ Document-method: Genmodel::DoubleVector2d.dup
21656
21956
 
21657
21957
  call-seq:
21658
- dup -> BoolVector
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
- _wrap_BoolVector_dup(int argc, VALUE *argv, VALUE self) {
21664
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
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< bool,std::allocator< bool > > *result = 0 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","dup", 1, self ));
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< bool > * >(argp1);
21977
+ arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
21678
21978
  {
21679
21979
  try {
21680
- result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_Sg__dup(arg1);
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), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_OWN | 0 );
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::BoolVector.inspect
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
- _wrap_BoolVector_inspect(int argc, VALUE *argv, VALUE self) {
21707
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","inspect", 1, self ));
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< bool > * >(argp1);
22020
+ arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
21721
22021
  {
21722
22022
  try {
21723
- result = (VALUE)std_vector_Sl_bool_Sg__inspect(arg1);
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::BoolVector.to_a
22041
+ Document-method: Genmodel::DoubleVector2d.to_a
21742
22042
 
21743
22043
  call-seq:
21744
22044
  to_a -> VALUE
21745
22045
 
21746
- Convert BoolVector to an Array.
22046
+ Convert DoubleVector2d to an Array.
21747
22047
  */
21748
22048
  SWIGINTERN VALUE
21749
- _wrap_BoolVector_to_a(int argc, VALUE *argv, VALUE self) {
21750
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","to_a", 1, self ));
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< bool > * >(argp1);
22063
+ arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
21764
22064
  {
21765
22065
  try {
21766
- result = (VALUE)std_vector_Sl_bool_Sg__to_a(arg1);
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::BoolVector.to_s
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
- _wrap_BoolVector_to_s(int argc, VALUE *argv, VALUE self) {
21793
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","to_s", 1, self ));
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< bool > * >(argp1);
22106
+ arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
21807
22107
  {
21808
22108
  try {
21809
- result = (VALUE)std_vector_Sl_bool_Sg__to_s(arg1);
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::BoolVector.slice
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 BoolVector.
22132
+ Return a slice (portion of) the DoubleVector2d.
21833
22133
  */
21834
22134
  SWIGINTERN VALUE
21835
- _wrap_BoolVector_slice(int argc, VALUE *argv, VALUE self) {
21836
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
21837
- std::vector< bool >::difference_type arg2 ;
21838
- std::vector< bool >::difference_type arg3 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","slice", 1, self ));
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< bool > * >(argp1);
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< bool >::difference_type","slice", 2, argv[0] ));
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< bool >::difference_type >(val2);
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< bool >::difference_type","slice", 3, argv[1] ));
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< bool >::difference_type >(val3);
22165
+ arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
21866
22166
  {
21867
22167
  try {
21868
- result = (VALUE)std_vector_Sl_bool_Sg__slice(arg1,arg2,arg3);
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::BoolVector.each
22186
+ Document-method: Genmodel::DoubleVector2d.each
21887
22187
 
21888
22188
  call-seq:
21889
- each -> BoolVector
22189
+ each -> DoubleVector2d
21890
22190
 
21891
- Iterate thru each element in the BoolVector. A block must be provided.
22191
+ Iterate thru each element in the DoubleVector2d. A block must be provided.
21892
22192
  */
21893
22193
  SWIGINTERN VALUE
21894
- _wrap_BoolVector_each(int argc, VALUE *argv, VALUE self) {
21895
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
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< bool,std::allocator< bool > > *result = 0 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","each", 1, self ));
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< bool > * >(argp1);
22208
+ arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
21909
22209
  {
21910
22210
  try {
21911
- result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_Sg__each(arg1);
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), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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::BoolVector.select
22229
+ Document-method: Genmodel::DoubleVector2d.select
21930
22230
 
21931
22231
  call-seq:
21932
- select -> BoolVector
22232
+ select -> DoubleVector2d
21933
22233
 
21934
- Iterate thru each element in the BoolVector and select those that match a condition. A block must be provided.
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
- _wrap_BoolVector_select(int argc, VALUE *argv, VALUE self) {
21938
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
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< bool,std::allocator< bool > > *result = 0 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","select", 1, self ));
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< bool > * >(argp1);
22251
+ arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
21952
22252
  {
21953
22253
  try {
21954
- result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_Sg__select(arg1);
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), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_OWN | 0 );
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::BoolVector.delete_at
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
- _wrap_BoolVector_delete_at(int argc, VALUE *argv, VALUE self) {
21981
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
21982
- std::vector< bool >::difference_type arg2 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","delete_at", 1, self ));
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< bool > * >(argp1);
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< bool >::difference_type","delete_at", 2, argv[0] ));
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< bool >::difference_type >(val2);
22302
+ arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
22003
22303
  {
22004
22304
  try {
22005
- result = (VALUE)std_vector_Sl_bool_Sg__delete_at(arg1,arg2);
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
- _wrap_BoolVector___delete2__(int argc, VALUE *argv, VALUE self) {
22023
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
22024
- std::vector< bool >::value_type *arg2 = 0 ;
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
- std::vector< bool >::value_type temp2 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","__delete2__", 1, self ));
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)std_vector_Sl_bool_Sg____delete2__(arg1,(bool const &)*arg2);
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::BoolVector.reject!
22372
+ Document-method: Genmodel::DoubleVector2d.reject!
22068
22373
 
22069
22374
  call-seq:
22070
- reject! -> BoolVector
22375
+ reject! -> DoubleVector2d
22071
22376
 
22072
- Iterate thru each element in the BoolVector and reject those that fail a condition. A block must be provided. BoolVector is modified in place.
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
- _wrap_BoolVector_rejectN___(int argc, VALUE *argv, VALUE self) {
22076
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
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< bool,std::allocator< bool > > *result = 0 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","reject_bang", 1, self ));
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< bool > * >(argp1);
22394
+ arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
22090
22395
  {
22091
22396
  try {
22092
- result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_Sg__reject_bang(arg1);
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), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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::BoolVector.pop
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 BoolVector.
22420
+ Remove and return element at the end of the DoubleVector2d.
22116
22421
  */
22117
22422
  SWIGINTERN VALUE
22118
- _wrap_BoolVector_pop(int argc, VALUE *argv, VALUE self) {
22119
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","pop", 1, self ));
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< bool > * >(argp1);
22437
+ arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
22133
22438
  {
22134
22439
  try {
22135
- result = (VALUE)std_vector_Sl_bool_Sg__pop(arg1);
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::BoolVector.push
22458
+ Document-method: Genmodel::DoubleVector2d.push
22154
22459
 
22155
22460
  call-seq:
22156
- push(e) -> std::vector< bool >::value_type const
22461
+ push(e) -> DoubleVector
22157
22462
 
22158
- Add an element at the end of the BoolVector.
22463
+ Add an element at the end of the DoubleVector2d.
22159
22464
  */
22160
22465
  SWIGINTERN VALUE
22161
- _wrap_BoolVector_push(int argc, VALUE *argv, VALUE self) {
22162
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
22163
- std::vector< bool >::value_type *arg2 = 0 ;
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
- std::vector< bool >::value_type temp2 ;
22167
- bool val2 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","push", 1, self ));
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< bool >::value_type)std_vector_Sl_bool_Sg__push(arg1,(bool const &)*arg2);
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 = SWIG_From_bool(static_cast< bool >(result));
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::BoolVector.reject
22516
+ Document-method: Genmodel::DoubleVector2d.reject
22207
22517
 
22208
22518
  call-seq:
22209
- reject -> BoolVector
22519
+ reject -> DoubleVector2d
22210
22520
 
22211
- Iterate thru each element in the BoolVector and reject those that fail a condition returning a new BoolVector. A block must be provided.
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
- _wrap_BoolVector_reject(int argc, VALUE *argv, VALUE self) {
22215
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
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< bool,std::allocator< bool > > *result = 0 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","reject", 1, self ));
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< bool > * >(argp1);
22538
+ arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
22229
22539
  {
22230
22540
  try {
22231
- result = (std::vector< bool,std::allocator< bool > > *)std_vector_Sl_bool_Sg__reject(arg1);
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), SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, SWIG_POINTER_OWN | 0 );
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::BoolVector.at
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
- _wrap_BoolVector_at(int argc, VALUE *argv, VALUE self) {
22258
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
22259
- std::vector< bool >::difference_type arg2 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > const *","at", 1, self ));
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< bool > * >(argp1);
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< bool >::difference_type","at", 2, argv[0] ));
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< bool >::difference_type >(val2);
22589
+ arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
22280
22590
  {
22281
22591
  try {
22282
- result = (VALUE)std_vector_Sl_bool_Sg__at((std::vector< bool > const *)arg1,arg2);
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::BoolVector.[]
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
- _wrap_BoolVector___getitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
22311
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
22312
- std::vector< bool >::difference_type arg2 ;
22313
- std::vector< bool >::difference_type arg3 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > const *","__getitem__", 1, self ));
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< bool > * >(argp1);
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< bool >::difference_type","__getitem__", 2, argv[0] ));
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< bool >::difference_type >(val2);
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< bool >::difference_type","__getitem__", 3, argv[1] ));
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< bool >::difference_type >(val3);
22650
+ arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
22341
22651
  {
22342
22652
  try {
22343
- result = (VALUE)std_vector_Sl_bool_Sg____getitem____SWIG_0((std::vector< bool > const *)arg1,arg2,arg3);
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
- _wrap_BoolVector___getitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
22361
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
22362
- std::vector< bool >::difference_type arg2 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > const *","__getitem__", 1, self ));
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< bool > * >(argp1);
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< bool >::difference_type","__getitem__", 2, argv[0] ));
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< bool >::difference_type >(val2);
22692
+ arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
22383
22693
  {
22384
22694
  try {
22385
- result = (VALUE)std_vector_Sl_bool_Sg____getitem____SWIG_1((std::vector< bool > const *)arg1,arg2);
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
- _wrap_BoolVector___getitem____SWIG_2(int argc, VALUE *argv, VALUE self) {
22403
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > const *","__getitem__", 1, self ));
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< bool > * >(argp1);
22727
+ arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
22418
22728
  arg2 = argv[0];
22419
22729
  {
22420
22730
  try {
22421
- result = (VALUE)std_vector_Sl_bool_Sg____getitem____SWIG_2((std::vector< bool > const *)arg1,arg2);
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 _wrap_BoolVector___getitem__(int nargs, VALUE *args, VALUE self) {
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<bool,std::allocator< bool > >**)(0));
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 _wrap_BoolVector___getitem____SWIG_1(nargs, args, self);
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<bool,std::allocator< bool > >**)(0));
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 _wrap_BoolVector___getitem____SWIG_2(nargs, args, self);
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<bool,std::allocator< bool > >**)(0));
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 _wrap_BoolVector___getitem____SWIG_0(nargs, args, self);
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< bool >::difference_type i, std::vector< bool >::difference_type j)\n"
22497
- " VALUE __getitem__(std::vector< bool >::difference_type i)\n"
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::BoolVector.[]=
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
- _wrap_BoolVector___setitem____SWIG_0(int argc, VALUE *argv, VALUE self) {
22516
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
22517
- std::vector< bool >::difference_type arg2 ;
22518
- std::vector< bool >::value_type *arg3 = 0 ;
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
- std::vector< bool >::value_type temp3 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","__setitem__", 1, self ));
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< bool > * >(argp1);
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< bool >::difference_type","__setitem__", 2, argv[0] ));
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
- temp3 = static_cast< std::vector< bool >::value_type >(val3);
22547
- arg3 = &temp3;
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)std_vector_Sl_bool_Sg____setitem____SWIG_0(arg1,arg2,(bool const &)*arg3);
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
- _wrap_BoolVector___setitem____SWIG_1(int argc, VALUE *argv, VALUE self) {
22568
- std::vector< bool > *arg1 = (std::vector< bool > *) 0 ;
22569
- std::vector< bool >::difference_type arg2 ;
22570
- std::vector< bool >::difference_type arg3 ;
22571
- std::vector< bool,std::allocator< bool > > *arg4 = 0 ;
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,SWIGTYPE_p_std__vectorT_bool_std__allocatorT_bool_t_t, 0 | 0 );
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< bool > *","__setitem__", 1, self ));
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< bool > * >(argp1);
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< bool >::difference_type","__setitem__", 2, argv[0] ));
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< bool >::difference_type >(val2);
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< bool >::difference_type","__setitem__", 3, argv[1] ));
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< bool >::difference_type >(val3);
22914
+ arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
22600
22915
  {
22601
- std::vector<bool,std::allocator< bool > > *ptr = (std::vector<bool,std::allocator< bool > > *)0;
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< bool,std::allocator< bool > > const &","__setitem__", 4, argv[2] ));
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< bool,std::allocator< bool > > const &","__setitem__", 4, argv[2]));
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)std_vector_Sl_bool_Sg____setitem____SWIG_1(arg1,arg2,arg3,(std::vector< bool,std::allocator< bool > > const &)*arg4);
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
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_vectorT_string_t, 0 );
27771
- if (!SWIG_IsOK(res2)) {
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
- if (arg1) (arg1)->name = arg2;
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 = ((arg1)->name);
27804
- vresult = SWIG_NewPointerObj((new vector< string >(static_cast< const vector< string >& >(result))), SWIGTYPE_p_vectorT_string_t, SWIG_POINTER_OWN | 0 );
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
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_vectorT_double_t, 0 );
27830
- if (!SWIG_IsOK(res2)) {
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
- if (arg1) (arg1)->obj = arg2;
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 = ((arg1)->obj);
27863
- vresult = SWIG_NewPointerObj((new vector< double >(static_cast< const vector< double >& >(result))), SWIGTYPE_p_vectorT_double_t, SWIG_POINTER_OWN | 0 );
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
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_vectorT_char_t, 0 );
27889
- if (!SWIG_IsOK(res2)) {
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
- if (arg1) (arg1)->type = arg2;
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 = ((arg1)->type);
27922
- vresult = SWIG_NewPointerObj((new vector< char >(static_cast< const vector< char >& >(result))), SWIGTYPE_p_vectorT_char_t, SWIG_POINTER_OWN | 0 );
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
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_vectorT_double_t, 0 );
28007
- if (!SWIG_IsOK(res2)) {
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
- if (arg1) (arg1)->ub = arg2;
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 = ((arg1)->ub);
28040
- vresult = SWIG_NewPointerObj((new vector< double >(static_cast< const vector< double >& >(result))), SWIGTYPE_p_vectorT_double_t, SWIG_POINTER_OWN | 0 );
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
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_vectorT_double_t, 0 );
28066
- if (!SWIG_IsOK(res2)) {
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
- if (arg1) (arg1)->lb = arg2;
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 = ((arg1)->lb);
28099
- vresult = SWIG_NewPointerObj((new vector< double >(static_cast< const vector< double >& >(result))), SWIGTYPE_p_vectorT_double_t, SWIG_POINTER_OWN | 0 );
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
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_vectorT_double_t, 0 );
28178
- if (!SWIG_IsOK(res2)) {
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
- if (arg1) (arg1)->rc = arg2;
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 = ((arg1)->rc);
28211
- vresult = SWIG_NewPointerObj((new vector< double >(static_cast< const vector< double >& >(result))), SWIGTYPE_p_vectorT_double_t, SWIG_POINTER_OWN | 0 );
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
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_vectorT_double_t, 0 );
28237
- if (!SWIG_IsOK(res2)) {
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
- if (arg1) (arg1)->qobj = arg2;
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 = ((arg1)->qobj);
28270
- vresult = SWIG_NewPointerObj((new vector< double >(static_cast< const vector< double >& >(result))), SWIGTYPE_p_vectorT_double_t, SWIG_POINTER_OWN | 0 );
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
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_vectorT_long_t, 0 );
28296
- if (!SWIG_IsOK(res2)) {
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
- if (arg1) (arg1)->qi = arg2;
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 = ((arg1)->qi);
28329
- vresult = SWIG_NewPointerObj((new vector< long >(static_cast< const vector< long >& >(result))), SWIGTYPE_p_vectorT_long_t, SWIG_POINTER_OWN | 0 );
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
- res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_vectorT_long_t, 0 );
28355
- if (!SWIG_IsOK(res2)) {
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
- if (arg1) (arg1)->qj = arg2;
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 = ((arg1)->qj);
28388
- vresult = SWIG_NewPointerObj((new vector< long >(static_cast< const vector< long >& >(result))), SWIGTYPE_p_vectorT_long_t, SWIG_POINTER_OWN | 0 );
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);