diff --git a/Core/PythonAPI/libBornAgainCore.py b/Core/PythonAPI/libBornAgainCore.py
index 3b2a9ea2bda6aba3b6bd7770845f13f10f733d30..88e4f7dbece552e31ce5b118b4224c7190b0c2a6 100644
--- a/Core/PythonAPI/libBornAgainCore.py
+++ b/Core/PythonAPI/libBornAgainCore.py
@@ -1,5 +1,5 @@
 # This file was automatically generated by SWIG (http://www.swig.org).
-# Version 3.0.8
+# Version 3.0.7
 #
 # Do not make changes to this file unless you know what you are doing--modify
 # the SWIG interface file instead.
@@ -77,7 +77,7 @@ def _swig_getattr(self, class_type, name):
 def _swig_repr(self):
     try:
         strthis = "proxy of " + self.this.__repr__()
-    except Exception:
+    except:
         strthis = ""
     return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
 
@@ -93,13 +93,12 @@ except AttributeError:
 try:
     import weakref
     weakref_proxy = weakref.proxy
-except Exception:
+except:
     weakref_proxy = lambda x: x
 
 
 class SwigPyIterator(_object):
-    """Proxy of C++ swig::SwigPyIterator class."""
-
+    """Proxy of C++ swig::SwigPyIterator class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
     __swig_getmethods__ = {}
@@ -208,8 +207,7 @@ SwigPyIterator_swigregister(SwigPyIterator)
 _libBornAgainCore.SHARED_PTR_DISOWN_swigconstant(_libBornAgainCore)
 SHARED_PTR_DISOWN = _libBornAgainCore.SHARED_PTR_DISOWN
 class vdouble1d_t(_object):
-    """Proxy of C++ std::vector<(double)> class."""
-
+    """Proxy of C++ std::vector<(double)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vdouble1d_t, name, value)
     __swig_getmethods__ = {}
@@ -238,6 +236,11 @@ class vdouble1d_t(_object):
         return _libBornAgainCore.vdouble1d_t___len__(self)
 
 
+    def pop(self):
+        """pop(vdouble1d_t self) -> std::vector< double >::value_type"""
+        return _libBornAgainCore.vdouble1d_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> vdouble1d_t"""
         return _libBornAgainCore.vdouble1d_t___getslice__(self, i, j)
@@ -245,8 +248,8 @@ class vdouble1d_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
         __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, vdouble1d_t v)
+        __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
         """
         return _libBornAgainCore.vdouble1d_t___setslice__(self, *args)
 
@@ -281,11 +284,6 @@ class vdouble1d_t(_object):
         return _libBornAgainCore.vdouble1d_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vdouble1d_t self) -> std::vector< double >::value_type"""
-        return _libBornAgainCore.vdouble1d_t_pop(self)
-
-
     def append(self, x):
         """append(vdouble1d_t self, std::vector< double >::value_type const & x)"""
         return _libBornAgainCore.vdouble1d_t_append(self, x)
@@ -301,11 +299,21 @@ class vdouble1d_t(_object):
         return _libBornAgainCore.vdouble1d_t_size(self)
 
 
+    def clear(self):
+        """clear(vdouble1d_t self)"""
+        return _libBornAgainCore.vdouble1d_t_clear(self)
+
+
     def swap(self, v):
         """swap(vdouble1d_t self, vdouble1d_t v)"""
         return _libBornAgainCore.vdouble1d_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"""
+        return _libBornAgainCore.vdouble1d_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vdouble1d_t self) -> std::vector< double >::iterator"""
         return _libBornAgainCore.vdouble1d_t_begin(self)
@@ -326,16 +334,6 @@ class vdouble1d_t(_object):
         return _libBornAgainCore.vdouble1d_t_rend(self)
 
 
-    def clear(self):
-        """clear(vdouble1d_t self)"""
-        return _libBornAgainCore.vdouble1d_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"""
-        return _libBornAgainCore.vdouble1d_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vdouble1d_t self)"""
         return _libBornAgainCore.vdouble1d_t_pop_back(self)
@@ -359,7 +357,7 @@ class vdouble1d_t(_object):
         this = _libBornAgainCore.new_vdouble1d_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -413,8 +411,7 @@ vdouble1d_t_swigregister = _libBornAgainCore.vdouble1d_t_swigregister
 vdouble1d_t_swigregister(vdouble1d_t)
 
 class vdouble2d_t(_object):
-    """Proxy of C++ std::vector<(std::vector<(double)>)> class."""
-
+    """Proxy of C++ std::vector<(std::vector<(double)>)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vdouble2d_t, name, value)
     __swig_getmethods__ = {}
@@ -443,6 +440,11 @@ class vdouble2d_t(_object):
         return _libBornAgainCore.vdouble2d_t___len__(self)
 
 
+    def pop(self):
+        """pop(vdouble2d_t self) -> vdouble1d_t"""
+        return _libBornAgainCore.vdouble2d_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> vdouble2d_t"""
         return _libBornAgainCore.vdouble2d_t___getslice__(self, i, j)
@@ -450,8 +452,8 @@ class vdouble2d_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)
         __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, vdouble2d_t v)
+        __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)
         """
         return _libBornAgainCore.vdouble2d_t___setslice__(self, *args)
 
@@ -486,11 +488,6 @@ class vdouble2d_t(_object):
         return _libBornAgainCore.vdouble2d_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vdouble2d_t self) -> vdouble1d_t"""
-        return _libBornAgainCore.vdouble2d_t_pop(self)
-
-
     def append(self, x):
         """append(vdouble2d_t self, vdouble1d_t x)"""
         return _libBornAgainCore.vdouble2d_t_append(self, x)
@@ -506,11 +503,21 @@ class vdouble2d_t(_object):
         return _libBornAgainCore.vdouble2d_t_size(self)
 
 
+    def clear(self):
+        """clear(vdouble2d_t self)"""
+        return _libBornAgainCore.vdouble2d_t_clear(self)
+
+
     def swap(self, v):
         """swap(vdouble2d_t self, vdouble2d_t v)"""
         return _libBornAgainCore.vdouble2d_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"""
+        return _libBornAgainCore.vdouble2d_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"""
         return _libBornAgainCore.vdouble2d_t_begin(self)
@@ -531,16 +538,6 @@ class vdouble2d_t(_object):
         return _libBornAgainCore.vdouble2d_t_rend(self)
 
 
-    def clear(self):
-        """clear(vdouble2d_t self)"""
-        return _libBornAgainCore.vdouble2d_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"""
-        return _libBornAgainCore.vdouble2d_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vdouble2d_t self)"""
         return _libBornAgainCore.vdouble2d_t_pop_back(self)
@@ -564,7 +561,7 @@ class vdouble2d_t(_object):
         this = _libBornAgainCore.new_vdouble2d_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -618,8 +615,7 @@ vdouble2d_t_swigregister = _libBornAgainCore.vdouble2d_t_swigregister
 vdouble2d_t_swigregister(vdouble2d_t)
 
 class vector_integer_t(_object):
-    """Proxy of C++ std::vector<(int)> class."""
-
+    """Proxy of C++ std::vector<(int)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_integer_t, name, value)
     __swig_getmethods__ = {}
@@ -648,6 +644,11 @@ class vector_integer_t(_object):
         return _libBornAgainCore.vector_integer_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_integer_t self) -> std::vector< int >::value_type"""
+        return _libBornAgainCore.vector_integer_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> vector_integer_t"""
         return _libBornAgainCore.vector_integer_t___getslice__(self, i, j)
@@ -655,8 +656,8 @@ class vector_integer_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
         __setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, vector_integer_t v)
+        __setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
         """
         return _libBornAgainCore.vector_integer_t___setslice__(self, *args)
 
@@ -691,11 +692,6 @@ class vector_integer_t(_object):
         return _libBornAgainCore.vector_integer_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_integer_t self) -> std::vector< int >::value_type"""
-        return _libBornAgainCore.vector_integer_t_pop(self)
-
-
     def append(self, x):
         """append(vector_integer_t self, std::vector< int >::value_type const & x)"""
         return _libBornAgainCore.vector_integer_t_append(self, x)
@@ -711,11 +707,21 @@ class vector_integer_t(_object):
         return _libBornAgainCore.vector_integer_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_integer_t self)"""
+        return _libBornAgainCore.vector_integer_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_integer_t self, vector_integer_t v)"""
         return _libBornAgainCore.vector_integer_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"""
+        return _libBornAgainCore.vector_integer_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_integer_t self) -> std::vector< int >::iterator"""
         return _libBornAgainCore.vector_integer_t_begin(self)
@@ -736,16 +742,6 @@ class vector_integer_t(_object):
         return _libBornAgainCore.vector_integer_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_integer_t self)"""
-        return _libBornAgainCore.vector_integer_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"""
-        return _libBornAgainCore.vector_integer_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_integer_t self)"""
         return _libBornAgainCore.vector_integer_t_pop_back(self)
@@ -769,7 +765,7 @@ class vector_integer_t(_object):
         this = _libBornAgainCore.new_vector_integer_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -823,8 +819,7 @@ vector_integer_t_swigregister = _libBornAgainCore.vector_integer_t_swigregister
 vector_integer_t_swigregister(vector_integer_t)
 
 class vector_longinteger_t(_object):
-    """Proxy of C++ std::vector<(unsigned long)> class."""
-
+    """Proxy of C++ std::vector<(unsigned long)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_longinteger_t, name, value)
     __swig_getmethods__ = {}
@@ -853,6 +848,11 @@ class vector_longinteger_t(_object):
         return _libBornAgainCore.vector_longinteger_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"""
+        return _libBornAgainCore.vector_longinteger_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j) -> vector_longinteger_t"""
         return _libBornAgainCore.vector_longinteger_t___getslice__(self, i, j)
@@ -860,8 +860,8 @@ class vector_longinteger_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)
         __setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, vector_longinteger_t v)
+        __setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)
         """
         return _libBornAgainCore.vector_longinteger_t___setslice__(self, *args)
 
@@ -896,11 +896,6 @@ class vector_longinteger_t(_object):
         return _libBornAgainCore.vector_longinteger_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"""
-        return _libBornAgainCore.vector_longinteger_t_pop(self)
-
-
     def append(self, x):
         """append(vector_longinteger_t self, std::vector< unsigned long >::value_type const & x)"""
         return _libBornAgainCore.vector_longinteger_t_append(self, x)
@@ -916,11 +911,21 @@ class vector_longinteger_t(_object):
         return _libBornAgainCore.vector_longinteger_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_longinteger_t self)"""
+        return _libBornAgainCore.vector_longinteger_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_longinteger_t self, vector_longinteger_t v)"""
         return _libBornAgainCore.vector_longinteger_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"""
+        return _libBornAgainCore.vector_longinteger_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"""
         return _libBornAgainCore.vector_longinteger_t_begin(self)
@@ -941,16 +946,6 @@ class vector_longinteger_t(_object):
         return _libBornAgainCore.vector_longinteger_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_longinteger_t self)"""
-        return _libBornAgainCore.vector_longinteger_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"""
-        return _libBornAgainCore.vector_longinteger_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_longinteger_t self)"""
         return _libBornAgainCore.vector_longinteger_t_pop_back(self)
@@ -974,7 +969,7 @@ class vector_longinteger_t(_object):
         this = _libBornAgainCore.new_vector_longinteger_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -1028,8 +1023,7 @@ vector_longinteger_t_swigregister = _libBornAgainCore.vector_longinteger_t_swigr
 vector_longinteger_t_swigregister(vector_longinteger_t)
 
 class vector_complex_t(_object):
-    """Proxy of C++ std::vector<(std::complex<(double)>)> class."""
-
+    """Proxy of C++ std::vector<(std::complex<(double)>)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_complex_t, name, value)
     __swig_getmethods__ = {}
@@ -1058,6 +1052,11 @@ class vector_complex_t(_object):
         return _libBornAgainCore.vector_complex_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"""
+        return _libBornAgainCore.vector_complex_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j) -> vector_complex_t"""
         return _libBornAgainCore.vector_complex_t___getslice__(self, i, j)
@@ -1065,8 +1064,8 @@ class vector_complex_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)
         __setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, vector_complex_t v)
+        __setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)
         """
         return _libBornAgainCore.vector_complex_t___setslice__(self, *args)
 
@@ -1101,11 +1100,6 @@ class vector_complex_t(_object):
         return _libBornAgainCore.vector_complex_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"""
-        return _libBornAgainCore.vector_complex_t_pop(self)
-
-
     def append(self, x):
         """append(vector_complex_t self, std::vector< std::complex< double > >::value_type const & x)"""
         return _libBornAgainCore.vector_complex_t_append(self, x)
@@ -1121,11 +1115,21 @@ class vector_complex_t(_object):
         return _libBornAgainCore.vector_complex_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_complex_t self)"""
+        return _libBornAgainCore.vector_complex_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_complex_t self, vector_complex_t v)"""
         return _libBornAgainCore.vector_complex_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"""
+        return _libBornAgainCore.vector_complex_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"""
         return _libBornAgainCore.vector_complex_t_begin(self)
@@ -1146,16 +1150,6 @@ class vector_complex_t(_object):
         return _libBornAgainCore.vector_complex_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_complex_t self)"""
-        return _libBornAgainCore.vector_complex_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"""
-        return _libBornAgainCore.vector_complex_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_complex_t self)"""
         return _libBornAgainCore.vector_complex_t_pop_back(self)
@@ -1179,7 +1173,7 @@ class vector_complex_t(_object):
         this = _libBornAgainCore.new_vector_complex_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -1233,8 +1227,7 @@ vector_complex_t_swigregister = _libBornAgainCore.vector_complex_t_swigregister
 vector_complex_t_swigregister(vector_complex_t)
 
 class vector_string_t(_object):
-    """Proxy of C++ std::vector<(std::string)> class."""
-
+    """Proxy of C++ std::vector<(std::string)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_string_t, name, value)
     __swig_getmethods__ = {}
@@ -1263,6 +1256,11 @@ class vector_string_t(_object):
         return _libBornAgainCore.vector_string_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_string_t self) -> std::vector< std::string >::value_type"""
+        return _libBornAgainCore.vector_string_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> vector_string_t"""
         return _libBornAgainCore.vector_string_t___getslice__(self, i, j)
@@ -1270,8 +1268,8 @@ class vector_string_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
         __setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, vector_string_t v)
+        __setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
         """
         return _libBornAgainCore.vector_string_t___setslice__(self, *args)
 
@@ -1306,11 +1304,6 @@ class vector_string_t(_object):
         return _libBornAgainCore.vector_string_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_string_t self) -> std::vector< std::string >::value_type"""
-        return _libBornAgainCore.vector_string_t_pop(self)
-
-
     def append(self, x):
         """append(vector_string_t self, std::vector< std::string >::value_type const & x)"""
         return _libBornAgainCore.vector_string_t_append(self, x)
@@ -1326,11 +1319,21 @@ class vector_string_t(_object):
         return _libBornAgainCore.vector_string_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_string_t self)"""
+        return _libBornAgainCore.vector_string_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_string_t self, vector_string_t v)"""
         return _libBornAgainCore.vector_string_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"""
+        return _libBornAgainCore.vector_string_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_string_t self) -> std::vector< std::string >::iterator"""
         return _libBornAgainCore.vector_string_t_begin(self)
@@ -1351,16 +1354,6 @@ class vector_string_t(_object):
         return _libBornAgainCore.vector_string_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_string_t self)"""
-        return _libBornAgainCore.vector_string_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"""
-        return _libBornAgainCore.vector_string_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_string_t self)"""
         return _libBornAgainCore.vector_string_t_pop_back(self)
@@ -1384,7 +1377,7 @@ class vector_string_t(_object):
         this = _libBornAgainCore.new_vector_string_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -1449,7 +1442,6 @@ class AttLimits(_object):
     C++ includes: AttLimits.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, AttLimits, name, value)
     __swig_getmethods__ = {}
@@ -1466,7 +1458,7 @@ class AttLimits(_object):
         this = _libBornAgainCore.new_AttLimits()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_AttLimits
     __del__ = lambda self: None
@@ -1746,7 +1738,6 @@ class ICloneable(_object):
     C++ includes: ICloneable.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, ICloneable, name, value)
     __swig_getmethods__ = {}
@@ -1767,7 +1758,7 @@ class ICloneable(_object):
         this = _libBornAgainCore.new_ICloneable(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_ICloneable
     __del__ = lambda self: None
@@ -1809,7 +1800,6 @@ class INamed(_object):
     C++ includes: INamed.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, INamed, name, value)
     __swig_getmethods__ = {}
@@ -1833,7 +1823,7 @@ class INamed(_object):
         this = _libBornAgainCore.new_INamed(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_INamed
     __del__ = lambda self: None
@@ -1865,7 +1855,6 @@ class INamedShared(_object):
     C++ includes: INamedShared.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, INamedShared, name, value)
     __swig_getmethods__ = {}
@@ -1889,7 +1878,7 @@ class INamedShared(_object):
         this = _libBornAgainCore.new_INamedShared(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_INamedShared
     __del__ = lambda self: None
@@ -1921,7 +1910,6 @@ class IParameterized(INamed):
     C++ includes: IParameterized.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [INamed]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -1948,7 +1936,7 @@ class IParameterized(INamed):
         this = _libBornAgainCore.new_IParameterized(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IParameterized
     __del__ = lambda self: None
@@ -2062,7 +2050,6 @@ class ParameterPattern(_object):
     C++ includes: IParameterized.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, ParameterPattern, name, value)
     __swig_getmethods__ = {}
@@ -2080,7 +2067,7 @@ class ParameterPattern(_object):
         this = _libBornAgainCore.new_ParameterPattern(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def beginsWith(self, start_type):
@@ -2118,8 +2105,7 @@ ParameterPattern_swigregister = _libBornAgainCore.ParameterPattern_swigregister
 ParameterPattern_swigregister(ParameterPattern)
 
 class IParameterizedShared(INamedShared):
-    """Proxy of C++ IParameterizedShared class."""
-
+    """Proxy of C++ IParameterizedShared class"""
     __swig_setmethods__ = {}
     for _s in [INamedShared]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2146,7 +2132,7 @@ class IParameterizedShared(INamedShared):
         this = _libBornAgainCore.new_IParameterizedShared(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IParameterizedShared
     __del__ = lambda self: None
@@ -2328,7 +2314,6 @@ class kvector_t(_object):
     C++ includes: BasicVector3D.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, kvector_t, name, value)
     __swig_getmethods__ = {}
@@ -2348,7 +2333,7 @@ class kvector_t(_object):
         this = _libBornAgainCore.new_kvector_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def x(self):
@@ -2658,8 +2643,7 @@ patch_version_number = cvar.patch_version_number
 PI2 = cvar.PI2
 
 class vector_kvector_t(_object):
-    """Proxy of C++ std::vector<(Geometry::BasicVector3D<(double)>)> class."""
-
+    """Proxy of C++ std::vector<(Geometry::BasicVector3D<(double)>)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_kvector_t, name, value)
     __swig_getmethods__ = {}
@@ -2688,6 +2672,11 @@ class vector_kvector_t(_object):
         return _libBornAgainCore.vector_kvector_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_kvector_t self) -> kvector_t"""
+        return _libBornAgainCore.vector_kvector_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_kvector_t self, std::vector< Geometry::BasicVector3D< double > >::difference_type i, std::vector< Geometry::BasicVector3D< double > >::difference_type j) -> vector_kvector_t"""
         return _libBornAgainCore.vector_kvector_t___getslice__(self, i, j)
@@ -2695,8 +2684,8 @@ class vector_kvector_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_kvector_t self, std::vector< Geometry::BasicVector3D< double > >::difference_type i, std::vector< Geometry::BasicVector3D< double > >::difference_type j)
         __setslice__(vector_kvector_t self, std::vector< Geometry::BasicVector3D< double > >::difference_type i, std::vector< Geometry::BasicVector3D< double > >::difference_type j, vector_kvector_t v)
+        __setslice__(vector_kvector_t self, std::vector< Geometry::BasicVector3D< double > >::difference_type i, std::vector< Geometry::BasicVector3D< double > >::difference_type j)
         """
         return _libBornAgainCore.vector_kvector_t___setslice__(self, *args)
 
@@ -2731,11 +2720,6 @@ class vector_kvector_t(_object):
         return _libBornAgainCore.vector_kvector_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_kvector_t self) -> kvector_t"""
-        return _libBornAgainCore.vector_kvector_t_pop(self)
-
-
     def append(self, x):
         """append(vector_kvector_t self, kvector_t x)"""
         return _libBornAgainCore.vector_kvector_t_append(self, x)
@@ -2751,11 +2735,21 @@ class vector_kvector_t(_object):
         return _libBornAgainCore.vector_kvector_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_kvector_t self)"""
+        return _libBornAgainCore.vector_kvector_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_kvector_t self, vector_kvector_t v)"""
         return _libBornAgainCore.vector_kvector_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_kvector_t self) -> std::vector< Geometry::BasicVector3D< double > >::allocator_type"""
+        return _libBornAgainCore.vector_kvector_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_kvector_t self) -> std::vector< Geometry::BasicVector3D< double > >::iterator"""
         return _libBornAgainCore.vector_kvector_t_begin(self)
@@ -2776,16 +2770,6 @@ class vector_kvector_t(_object):
         return _libBornAgainCore.vector_kvector_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_kvector_t self)"""
-        return _libBornAgainCore.vector_kvector_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_kvector_t self) -> std::vector< Geometry::BasicVector3D< double > >::allocator_type"""
-        return _libBornAgainCore.vector_kvector_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_kvector_t self)"""
         return _libBornAgainCore.vector_kvector_t_pop_back(self)
@@ -2809,7 +2793,7 @@ class vector_kvector_t(_object):
         this = _libBornAgainCore.new_vector_kvector_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -2871,7 +2855,6 @@ class cvector_t(_object):
     C++ includes: BasicVector3D.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, cvector_t, name, value)
     __swig_getmethods__ = {}
@@ -2891,7 +2874,7 @@ class cvector_t(_object):
         this = _libBornAgainCore.new_cvector_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def x(self):
@@ -3097,8 +3080,7 @@ cvector_t_swigregister = _libBornAgainCore.cvector_t_swigregister
 cvector_t_swigregister(cvector_t)
 
 class vector_cvector_t(_object):
-    """Proxy of C++ std::vector<(Geometry::BasicVector3D<(std::complex<(double)>)>)> class."""
-
+    """Proxy of C++ std::vector<(Geometry::BasicVector3D<(std::complex<(double)>)>)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_cvector_t, name, value)
     __swig_getmethods__ = {}
@@ -3127,6 +3109,11 @@ class vector_cvector_t(_object):
         return _libBornAgainCore.vector_cvector_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_cvector_t self) -> cvector_t"""
+        return _libBornAgainCore.vector_cvector_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_cvector_t self, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j) -> vector_cvector_t"""
         return _libBornAgainCore.vector_cvector_t___getslice__(self, i, j)
@@ -3134,8 +3121,8 @@ class vector_cvector_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_cvector_t self, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j)
         __setslice__(vector_cvector_t self, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j, vector_cvector_t v)
+        __setslice__(vector_cvector_t self, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j)
         """
         return _libBornAgainCore.vector_cvector_t___setslice__(self, *args)
 
@@ -3170,11 +3157,6 @@ class vector_cvector_t(_object):
         return _libBornAgainCore.vector_cvector_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_cvector_t self) -> cvector_t"""
-        return _libBornAgainCore.vector_cvector_t_pop(self)
-
-
     def append(self, x):
         """append(vector_cvector_t self, cvector_t x)"""
         return _libBornAgainCore.vector_cvector_t_append(self, x)
@@ -3190,11 +3172,21 @@ class vector_cvector_t(_object):
         return _libBornAgainCore.vector_cvector_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_cvector_t self)"""
+        return _libBornAgainCore.vector_cvector_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_cvector_t self, vector_cvector_t v)"""
         return _libBornAgainCore.vector_cvector_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_cvector_t self) -> std::vector< Geometry::BasicVector3D< std::complex< double > > >::allocator_type"""
+        return _libBornAgainCore.vector_cvector_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_cvector_t self) -> std::vector< Geometry::BasicVector3D< std::complex< double > > >::iterator"""
         return _libBornAgainCore.vector_cvector_t_begin(self)
@@ -3215,16 +3207,6 @@ class vector_cvector_t(_object):
         return _libBornAgainCore.vector_cvector_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_cvector_t self)"""
-        return _libBornAgainCore.vector_cvector_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_cvector_t self) -> std::vector< Geometry::BasicVector3D< std::complex< double > > >::allocator_type"""
-        return _libBornAgainCore.vector_cvector_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_cvector_t self)"""
         return _libBornAgainCore.vector_cvector_t_pop_back(self)
@@ -3248,7 +3230,7 @@ class vector_cvector_t(_object):
         this = _libBornAgainCore.new_vector_cvector_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -3328,7 +3310,6 @@ class WavevectorInfo(_object):
     C++ includes: WavevectorInfo.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, WavevectorInfo, name, value)
     __swig_getmethods__ = {}
@@ -3346,7 +3327,7 @@ class WavevectorInfo(_object):
         this = _libBornAgainCore.new_WavevectorInfo(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def getKi(self):
@@ -3422,7 +3403,6 @@ class Beam(IParameterized):
     C++ includes: Beam.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -3448,7 +3428,7 @@ class Beam(IParameterized):
         this = _libBornAgainCore.new_Beam(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_Beam
     __del__ = lambda self: None
@@ -3568,7 +3548,6 @@ class Bin1D(_object):
     C++ includes: Bin.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, Bin1D, name, value)
     __swig_getmethods__ = {}
@@ -3586,7 +3565,7 @@ class Bin1D(_object):
         this = _libBornAgainCore.new_Bin1D(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_setmethods__["m_lower"] = _libBornAgainCore.Bin1D_m_lower_set
     __swig_getmethods__["m_lower"] = _libBornAgainCore.Bin1D_m_lower_get
@@ -3630,7 +3609,6 @@ class Bin1DKVector(_object):
     C++ includes: Bin.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, Bin1DKVector, name, value)
     __swig_getmethods__ = {}
@@ -3651,7 +3629,7 @@ class Bin1DKVector(_object):
         this = _libBornAgainCore.new_Bin1DKVector(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def getMidPoint(self):
@@ -3695,7 +3673,6 @@ class Bin1DCVector(_object):
     C++ includes: Bin.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, Bin1DCVector, name, value)
     __swig_getmethods__ = {}
@@ -3716,7 +3693,7 @@ class Bin1DCVector(_object):
         this = _libBornAgainCore.new_Bin1DCVector(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def getMidPoint(self):
@@ -3760,7 +3737,6 @@ class IAxis(_object):
     C++ includes: IAxis.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, IAxis, name, value)
     __swig_getmethods__ = {}
@@ -3783,7 +3759,7 @@ class IAxis(_object):
         this = _libBornAgainCore.new_IAxis(_self, name)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -3991,7 +3967,6 @@ class VariableBinAxis(IAxis):
     C++ includes: VariableBinAxis.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IAxis]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -4148,7 +4123,7 @@ class VariableBinAxis(IAxis):
         this = _libBornAgainCore.new_VariableBinAxis(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def _print(self, ostr):
@@ -4181,7 +4156,6 @@ class ConstKBinAxis(VariableBinAxis):
     C++ includes: ConstKBinAxis.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [VariableBinAxis]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -4250,7 +4224,7 @@ class ConstKBinAxis(VariableBinAxis):
         this = _libBornAgainCore.new_ConstKBinAxis(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def _print(self, ostr):
@@ -4278,7 +4252,6 @@ class CustomBinAxis(VariableBinAxis):
     C++ includes: CustomBinAxis.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [VariableBinAxis]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -4320,7 +4293,7 @@ class CustomBinAxis(VariableBinAxis):
         this = _libBornAgainCore.new_CustomBinAxis(_self, name, nbins, start, end)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_CustomBinAxis
     __del__ = lambda self: None
@@ -4396,7 +4369,6 @@ class IShape2D(ICloneable):
     C++ includes: IShape2D.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ICloneable]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -4444,7 +4416,7 @@ class IShape2D(ICloneable):
         this = _libBornAgainCore.new_IShape2D(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IShape2D
     __del__ = lambda self: None
@@ -4464,7 +4436,6 @@ class ISample(ICloneable, IParameterized):
     C++ includes: ISample.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ICloneable, IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -4589,7 +4560,7 @@ class ISample(ICloneable, IParameterized):
         this = _libBornAgainCore.new_ISample(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_ISample
     __del__ = lambda self: None
@@ -4611,8 +4582,7 @@ ISample_swigregister = _libBornAgainCore.ISample_swigregister
 ISample_swigregister(ISample)
 
 class swig_dummy_type_isample_vector(_object):
-    """Proxy of C++ std::vector<(p.ISample)> class."""
-
+    """Proxy of C++ std::vector<(p.ISample)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, swig_dummy_type_isample_vector, name, value)
     __swig_getmethods__ = {}
@@ -4641,6 +4611,11 @@ class swig_dummy_type_isample_vector(_object):
         return _libBornAgainCore.swig_dummy_type_isample_vector___len__(self)
 
 
+    def pop(self):
+        """pop(swig_dummy_type_isample_vector self) -> ISample"""
+        return _libBornAgainCore.swig_dummy_type_isample_vector_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(swig_dummy_type_isample_vector self, std::vector< ISample * >::difference_type i, std::vector< ISample * >::difference_type j) -> swig_dummy_type_isample_vector"""
         return _libBornAgainCore.swig_dummy_type_isample_vector___getslice__(self, i, j)
@@ -4648,8 +4623,8 @@ class swig_dummy_type_isample_vector(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(swig_dummy_type_isample_vector self, std::vector< ISample * >::difference_type i, std::vector< ISample * >::difference_type j)
         __setslice__(swig_dummy_type_isample_vector self, std::vector< ISample * >::difference_type i, std::vector< ISample * >::difference_type j, swig_dummy_type_isample_vector v)
+        __setslice__(swig_dummy_type_isample_vector self, std::vector< ISample * >::difference_type i, std::vector< ISample * >::difference_type j)
         """
         return _libBornAgainCore.swig_dummy_type_isample_vector___setslice__(self, *args)
 
@@ -4684,11 +4659,6 @@ class swig_dummy_type_isample_vector(_object):
         return _libBornAgainCore.swig_dummy_type_isample_vector___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(swig_dummy_type_isample_vector self) -> ISample"""
-        return _libBornAgainCore.swig_dummy_type_isample_vector_pop(self)
-
-
     def append(self, x):
         """append(swig_dummy_type_isample_vector self, ISample x)"""
         return _libBornAgainCore.swig_dummy_type_isample_vector_append(self, x)
@@ -4704,11 +4674,21 @@ class swig_dummy_type_isample_vector(_object):
         return _libBornAgainCore.swig_dummy_type_isample_vector_size(self)
 
 
+    def clear(self):
+        """clear(swig_dummy_type_isample_vector self)"""
+        return _libBornAgainCore.swig_dummy_type_isample_vector_clear(self)
+
+
     def swap(self, v):
         """swap(swig_dummy_type_isample_vector self, swig_dummy_type_isample_vector v)"""
         return _libBornAgainCore.swig_dummy_type_isample_vector_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(swig_dummy_type_isample_vector self) -> std::vector< ISample * >::allocator_type"""
+        return _libBornAgainCore.swig_dummy_type_isample_vector_get_allocator(self)
+
+
     def begin(self):
         """begin(swig_dummy_type_isample_vector self) -> std::vector< ISample * >::iterator"""
         return _libBornAgainCore.swig_dummy_type_isample_vector_begin(self)
@@ -4729,16 +4709,6 @@ class swig_dummy_type_isample_vector(_object):
         return _libBornAgainCore.swig_dummy_type_isample_vector_rend(self)
 
 
-    def clear(self):
-        """clear(swig_dummy_type_isample_vector self)"""
-        return _libBornAgainCore.swig_dummy_type_isample_vector_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(swig_dummy_type_isample_vector self) -> std::vector< ISample * >::allocator_type"""
-        return _libBornAgainCore.swig_dummy_type_isample_vector_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(swig_dummy_type_isample_vector self)"""
         return _libBornAgainCore.swig_dummy_type_isample_vector_pop_back(self)
@@ -4762,7 +4732,7 @@ class swig_dummy_type_isample_vector(_object):
         this = _libBornAgainCore.new_swig_dummy_type_isample_vector(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -4816,8 +4786,7 @@ swig_dummy_type_isample_vector_swigregister = _libBornAgainCore.swig_dummy_type_
 swig_dummy_type_isample_vector_swigregister(swig_dummy_type_isample_vector)
 
 class swig_dummy_type_const_isample_vector(_object):
-    """Proxy of C++ std::vector<(p.q(const).ISample)> class."""
-
+    """Proxy of C++ std::vector<(p.q(const).ISample)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, swig_dummy_type_const_isample_vector, name, value)
     __swig_getmethods__ = {}
@@ -4846,6 +4815,11 @@ class swig_dummy_type_const_isample_vector(_object):
         return _libBornAgainCore.swig_dummy_type_const_isample_vector___len__(self)
 
 
+    def pop(self):
+        """pop(swig_dummy_type_const_isample_vector self) -> ISample"""
+        return _libBornAgainCore.swig_dummy_type_const_isample_vector_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(swig_dummy_type_const_isample_vector self, std::vector< ISample const * >::difference_type i, std::vector< ISample const * >::difference_type j) -> swig_dummy_type_const_isample_vector"""
         return _libBornAgainCore.swig_dummy_type_const_isample_vector___getslice__(self, i, j)
@@ -4853,8 +4827,8 @@ class swig_dummy_type_const_isample_vector(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(swig_dummy_type_const_isample_vector self, std::vector< ISample const * >::difference_type i, std::vector< ISample const * >::difference_type j)
         __setslice__(swig_dummy_type_const_isample_vector self, std::vector< ISample const * >::difference_type i, std::vector< ISample const * >::difference_type j, swig_dummy_type_const_isample_vector v)
+        __setslice__(swig_dummy_type_const_isample_vector self, std::vector< ISample const * >::difference_type i, std::vector< ISample const * >::difference_type j)
         """
         return _libBornAgainCore.swig_dummy_type_const_isample_vector___setslice__(self, *args)
 
@@ -4889,11 +4863,6 @@ class swig_dummy_type_const_isample_vector(_object):
         return _libBornAgainCore.swig_dummy_type_const_isample_vector___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(swig_dummy_type_const_isample_vector self) -> ISample"""
-        return _libBornAgainCore.swig_dummy_type_const_isample_vector_pop(self)
-
-
     def append(self, x):
         """append(swig_dummy_type_const_isample_vector self, ISample x)"""
         return _libBornAgainCore.swig_dummy_type_const_isample_vector_append(self, x)
@@ -4909,11 +4878,21 @@ class swig_dummy_type_const_isample_vector(_object):
         return _libBornAgainCore.swig_dummy_type_const_isample_vector_size(self)
 
 
+    def clear(self):
+        """clear(swig_dummy_type_const_isample_vector self)"""
+        return _libBornAgainCore.swig_dummy_type_const_isample_vector_clear(self)
+
+
     def swap(self, v):
         """swap(swig_dummy_type_const_isample_vector self, swig_dummy_type_const_isample_vector v)"""
         return _libBornAgainCore.swig_dummy_type_const_isample_vector_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(swig_dummy_type_const_isample_vector self) -> std::vector< ISample const * >::allocator_type"""
+        return _libBornAgainCore.swig_dummy_type_const_isample_vector_get_allocator(self)
+
+
     def begin(self):
         """begin(swig_dummy_type_const_isample_vector self) -> std::vector< ISample const * >::iterator"""
         return _libBornAgainCore.swig_dummy_type_const_isample_vector_begin(self)
@@ -4934,16 +4913,6 @@ class swig_dummy_type_const_isample_vector(_object):
         return _libBornAgainCore.swig_dummy_type_const_isample_vector_rend(self)
 
 
-    def clear(self):
-        """clear(swig_dummy_type_const_isample_vector self)"""
-        return _libBornAgainCore.swig_dummy_type_const_isample_vector_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(swig_dummy_type_const_isample_vector self) -> std::vector< ISample const * >::allocator_type"""
-        return _libBornAgainCore.swig_dummy_type_const_isample_vector_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(swig_dummy_type_const_isample_vector self)"""
         return _libBornAgainCore.swig_dummy_type_const_isample_vector_pop_back(self)
@@ -4967,7 +4936,7 @@ class swig_dummy_type_const_isample_vector(_object):
         this = _libBornAgainCore.new_swig_dummy_type_const_isample_vector(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -5029,7 +4998,6 @@ class ISampleBuilder(IParameterizedShared):
     C++ includes: ISampleBuilder.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IParameterizedShared]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -5054,7 +5022,7 @@ class ISampleBuilder(IParameterizedShared):
         this = _libBornAgainCore.new_ISampleBuilder(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_ISampleBuilder
     __del__ = lambda self: None
@@ -5119,7 +5087,6 @@ class ISampleVisitor(_object):
     C++ includes: ISampleVisitor.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, ISampleVisitor, name, value)
     __swig_getmethods__ = {}
@@ -5140,7 +5107,7 @@ class ISampleVisitor(_object):
         this = _libBornAgainCore.new_ISampleVisitor(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_ISampleVisitor
     __del__ = lambda self: None
@@ -5299,7 +5266,6 @@ class ICompositeSample(ISample):
     C++ includes: ICompositeSample.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ISample]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -5324,7 +5290,7 @@ class ICompositeSample(ISample):
         this = _libBornAgainCore.new_ICompositeSample(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_ICompositeSample
     __del__ = lambda self: None
@@ -5441,7 +5407,6 @@ class IClusteredParticles(ICompositeSample):
     C++ includes: IClusteredParticles.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ICompositeSample]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -5466,7 +5431,7 @@ class IClusteredParticles(ICompositeSample):
         this = _libBornAgainCore.new_IClusteredParticles(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IClusteredParticles
     __del__ = lambda self: None
@@ -5585,7 +5550,6 @@ class Crystal(IClusteredParticles):
     C++ includes: Crystal.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IClusteredParticles]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -5610,7 +5574,7 @@ class Crystal(IClusteredParticles):
         this = _libBornAgainCore.new_Crystal(_self, lattice_basis, lattice)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_Crystal
     __del__ = lambda self: None
@@ -5747,7 +5711,6 @@ class IDistribution1D(IParameterized):
     C++ includes: Distributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -5772,7 +5735,7 @@ class IDistribution1D(IParameterized):
         this = _libBornAgainCore.new_IDistribution1D(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IDistribution1D
     __del__ = lambda self: None
@@ -5901,7 +5864,6 @@ class DistributionGate(IDistribution1D):
     C++ includes: Distributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IDistribution1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -5927,7 +5889,7 @@ class DistributionGate(IDistribution1D):
         this = _libBornAgainCore.new_DistributionGate(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_DistributionGate
     __del__ = lambda self: None
@@ -6030,7 +5992,6 @@ class DistributionLorentz(IDistribution1D):
     C++ includes: Distributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IDistribution1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -6056,7 +6017,7 @@ class DistributionLorentz(IDistribution1D):
         this = _libBornAgainCore.new_DistributionLorentz(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_DistributionLorentz
     __del__ = lambda self: None
@@ -6147,7 +6108,6 @@ class DistributionGaussian(IDistribution1D):
     C++ includes: Distributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IDistribution1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -6173,7 +6133,7 @@ class DistributionGaussian(IDistribution1D):
         this = _libBornAgainCore.new_DistributionGaussian(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_DistributionGaussian
     __del__ = lambda self: None
@@ -6264,7 +6224,6 @@ class DistributionLogNormal(IDistribution1D):
     C++ includes: Distributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IDistribution1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -6290,7 +6249,7 @@ class DistributionLogNormal(IDistribution1D):
         this = _libBornAgainCore.new_DistributionLogNormal(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_DistributionLogNormal
     __del__ = lambda self: None
@@ -6393,7 +6352,6 @@ class DistributionCosine(IDistribution1D):
     C++ includes: Distributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IDistribution1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -6419,7 +6377,7 @@ class DistributionCosine(IDistribution1D):
         this = _libBornAgainCore.new_DistributionCosine(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_DistributionCosine
     __del__ = lambda self: None
@@ -6510,7 +6468,6 @@ class Ellipse(IShape2D):
     C++ includes: Ellipse.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IShape2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -6556,7 +6513,7 @@ class Ellipse(IShape2D):
         this = _libBornAgainCore.new_Ellipse(_self, xcenter, ycenter, xradius, yradius, theta)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -6654,7 +6611,6 @@ class IFTDecayFunction1D(IParameterized):
     C++ includes: FTDecayFunctions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -6679,7 +6635,7 @@ class IFTDecayFunction1D(IParameterized):
         this = _libBornAgainCore.new_IFTDecayFunction1D(_self, omega)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IFTDecayFunction1D
     __del__ = lambda self: None
@@ -6749,7 +6705,6 @@ class FTDecayFunction1DCauchy(IFTDecayFunction1D):
     C++ includes: FTDecayFunctions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDecayFunction1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -6774,7 +6729,7 @@ class FTDecayFunction1DCauchy(IFTDecayFunction1D):
         this = _libBornAgainCore.new_FTDecayFunction1DCauchy(_self, omega)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDecayFunction1DCauchy
     __del__ = lambda self: None
@@ -6824,7 +6779,6 @@ class FTDecayFunction1DGauss(IFTDecayFunction1D):
     C++ includes: FTDecayFunctions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDecayFunction1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -6849,7 +6803,7 @@ class FTDecayFunction1DGauss(IFTDecayFunction1D):
         this = _libBornAgainCore.new_FTDecayFunction1DGauss(_self, omega)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDecayFunction1DGauss
     __del__ = lambda self: None
@@ -6899,7 +6853,6 @@ class FTDecayFunction1DTriangle(IFTDecayFunction1D):
     C++ includes: FTDecayFunctions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDecayFunction1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -6924,7 +6877,7 @@ class FTDecayFunction1DTriangle(IFTDecayFunction1D):
         this = _libBornAgainCore.new_FTDecayFunction1DTriangle(_self, omega)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDecayFunction1DTriangle
     __del__ = lambda self: None
@@ -6974,7 +6927,6 @@ class FTDecayFunction1DVoigt(IFTDecayFunction1D):
     C++ includes: FTDecayFunctions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDecayFunction1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -6999,7 +6951,7 @@ class FTDecayFunction1DVoigt(IFTDecayFunction1D):
         this = _libBornAgainCore.new_FTDecayFunction1DVoigt(_self, omega, eta)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDecayFunction1DVoigt
     __del__ = lambda self: None
@@ -7059,7 +7011,6 @@ class IFTDecayFunction2D(IParameterized):
     C++ includes: FTDecayFunctions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -7084,7 +7035,7 @@ class IFTDecayFunction2D(IParameterized):
         this = _libBornAgainCore.new_IFTDecayFunction2D(_self, decay_length_x, decay_length_y)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IFTDecayFunction2D
     __del__ = lambda self: None
@@ -7208,7 +7159,6 @@ class FTDecayFunction2DCauchy(IFTDecayFunction2D):
     C++ includes: FTDecayFunctions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDecayFunction2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -7233,7 +7183,7 @@ class FTDecayFunction2DCauchy(IFTDecayFunction2D):
         this = _libBornAgainCore.new_FTDecayFunction2DCauchy(_self, decay_length_x, decay_length_y)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDecayFunction2DCauchy
     __del__ = lambda self: None
@@ -7285,7 +7235,6 @@ class FTDecayFunction2DGauss(IFTDecayFunction2D):
     C++ includes: FTDecayFunctions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDecayFunction2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -7310,7 +7259,7 @@ class FTDecayFunction2DGauss(IFTDecayFunction2D):
         this = _libBornAgainCore.new_FTDecayFunction2DGauss(_self, decay_length_x, decay_length_y)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDecayFunction2DGauss
     __del__ = lambda self: None
@@ -7362,7 +7311,6 @@ class FTDecayFunction2DVoigt(IFTDecayFunction2D):
     C++ includes: FTDecayFunctions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDecayFunction2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -7387,7 +7335,7 @@ class FTDecayFunction2DVoigt(IFTDecayFunction2D):
         this = _libBornAgainCore.new_FTDecayFunction2DVoigt(_self, decay_length_x, decay_length_y, eta)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDecayFunction2DVoigt
     __del__ = lambda self: None
@@ -7449,7 +7397,6 @@ class IFTDistribution1D(IParameterized):
     C++ includes: FTDistributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -7474,7 +7421,7 @@ class IFTDistribution1D(IParameterized):
         this = _libBornAgainCore.new_IFTDistribution1D(_self, omega)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IFTDistribution1D
     __del__ = lambda self: None
@@ -7544,7 +7491,6 @@ class FTDistribution1DCauchy(IFTDistribution1D):
     C++ includes: FTDistributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDistribution1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -7569,7 +7515,7 @@ class FTDistribution1DCauchy(IFTDistribution1D):
         this = _libBornAgainCore.new_FTDistribution1DCauchy(_self, omega)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDistribution1DCauchy
     __del__ = lambda self: None
@@ -7619,7 +7565,6 @@ class FTDistribution1DGauss(IFTDistribution1D):
     C++ includes: FTDistributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDistribution1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -7644,7 +7589,7 @@ class FTDistribution1DGauss(IFTDistribution1D):
         this = _libBornAgainCore.new_FTDistribution1DGauss(_self, omega)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDistribution1DGauss
     __del__ = lambda self: None
@@ -7694,7 +7639,6 @@ class FTDistribution1DGate(IFTDistribution1D):
     C++ includes: FTDistributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDistribution1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -7719,7 +7663,7 @@ class FTDistribution1DGate(IFTDistribution1D):
         this = _libBornAgainCore.new_FTDistribution1DGate(_self, omega)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDistribution1DGate
     __del__ = lambda self: None
@@ -7769,7 +7713,6 @@ class FTDistribution1DTriangle(IFTDistribution1D):
     C++ includes: FTDistributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDistribution1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -7794,7 +7737,7 @@ class FTDistribution1DTriangle(IFTDistribution1D):
         this = _libBornAgainCore.new_FTDistribution1DTriangle(_self, omega)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDistribution1DTriangle
     __del__ = lambda self: None
@@ -7844,7 +7787,6 @@ class FTDistribution1DCosine(IFTDistribution1D):
     C++ includes: FTDistributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDistribution1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -7869,7 +7811,7 @@ class FTDistribution1DCosine(IFTDistribution1D):
         this = _libBornAgainCore.new_FTDistribution1DCosine(_self, omega)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDistribution1DCosine
     __del__ = lambda self: None
@@ -7919,7 +7861,6 @@ class FTDistribution1DVoigt(IFTDistribution1D):
     C++ includes: FTDistributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDistribution1D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -7944,7 +7885,7 @@ class FTDistribution1DVoigt(IFTDistribution1D):
         this = _libBornAgainCore.new_FTDistribution1DVoigt(_self, omega, eta)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDistribution1DVoigt
     __del__ = lambda self: None
@@ -8004,7 +7945,6 @@ class IFTDistribution2D(IParameterized):
     C++ includes: FTDistributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -8029,7 +7969,7 @@ class IFTDistribution2D(IParameterized):
         this = _libBornAgainCore.new_IFTDistribution2D(_self, coherence_length_x, coherence_length_y)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IFTDistribution2D
     __del__ = lambda self: None
@@ -8131,7 +8071,6 @@ class FTDistribution2DCauchy(IFTDistribution2D):
     C++ includes: FTDistributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDistribution2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -8156,7 +8095,7 @@ class FTDistribution2DCauchy(IFTDistribution2D):
         this = _libBornAgainCore.new_FTDistribution2DCauchy(_self, coherence_length_x, coherence_length_y)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDistribution2DCauchy
     __del__ = lambda self: None
@@ -8208,7 +8147,6 @@ class FTDistribution2DGauss(IFTDistribution2D):
     C++ includes: FTDistributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDistribution2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -8233,7 +8171,7 @@ class FTDistribution2DGauss(IFTDistribution2D):
         this = _libBornAgainCore.new_FTDistribution2DGauss(_self, coherence_length_x, coherence_length_y)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDistribution2DGauss
     __del__ = lambda self: None
@@ -8285,7 +8223,6 @@ class FTDistribution2DGate(IFTDistribution2D):
     C++ includes: FTDistributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDistribution2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -8310,7 +8247,7 @@ class FTDistribution2DGate(IFTDistribution2D):
         this = _libBornAgainCore.new_FTDistribution2DGate(_self, coherence_length_x, coherence_length_y)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDistribution2DGate
     __del__ = lambda self: None
@@ -8362,7 +8299,6 @@ class FTDistribution2DCone(IFTDistribution2D):
     C++ includes: FTDistributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDistribution2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -8387,7 +8323,7 @@ class FTDistribution2DCone(IFTDistribution2D):
         this = _libBornAgainCore.new_FTDistribution2DCone(_self, coherence_length_x, coherence_length_y)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDistribution2DCone
     __del__ = lambda self: None
@@ -8439,7 +8375,6 @@ class FTDistribution2DVoigt(IFTDistribution2D):
     C++ includes: FTDistributions.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFTDistribution2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -8464,7 +8399,7 @@ class FTDistribution2DVoigt(IFTDistribution2D):
         this = _libBornAgainCore.new_FTDistribution2DVoigt(_self, coherence_length_x, coherence_length_y, eta)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FTDistribution2DVoigt
     __del__ = lambda self: None
@@ -8526,7 +8461,6 @@ class FixedBinAxis(IAxis):
     C++ includes: FixedBinAxis.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IAxis]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -8568,7 +8502,7 @@ class FixedBinAxis(IAxis):
         this = _libBornAgainCore.new_FixedBinAxis(_self, name, nbins, start, end)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FixedBinAxis
     __del__ = lambda self: None
@@ -8717,7 +8651,6 @@ class IFormFactor(ISample):
     C++ includes: IFormFactor.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ISample]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -8742,7 +8675,7 @@ class IFormFactor(ISample):
         this = _libBornAgainCore.new_IFormFactor(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IFormFactor
     __del__ = lambda self: None
@@ -8857,8 +8790,7 @@ IFormFactor_swigregister = _libBornAgainCore.IFormFactor_swigregister
 IFormFactor_swigregister(IFormFactor)
 
 class vector_IFormFactorPtr_t(_object):
-    """Proxy of C++ std::vector<(p.IFormFactor)> class."""
-
+    """Proxy of C++ std::vector<(p.IFormFactor)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_IFormFactorPtr_t, name, value)
     __swig_getmethods__ = {}
@@ -8887,6 +8819,11 @@ class vector_IFormFactorPtr_t(_object):
         return _libBornAgainCore.vector_IFormFactorPtr_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_IFormFactorPtr_t self) -> IFormFactor"""
+        return _libBornAgainCore.vector_IFormFactorPtr_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_IFormFactorPtr_t self, std::vector< IFormFactor * >::difference_type i, std::vector< IFormFactor * >::difference_type j) -> vector_IFormFactorPtr_t"""
         return _libBornAgainCore.vector_IFormFactorPtr_t___getslice__(self, i, j)
@@ -8894,8 +8831,8 @@ class vector_IFormFactorPtr_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_IFormFactorPtr_t self, std::vector< IFormFactor * >::difference_type i, std::vector< IFormFactor * >::difference_type j)
         __setslice__(vector_IFormFactorPtr_t self, std::vector< IFormFactor * >::difference_type i, std::vector< IFormFactor * >::difference_type j, vector_IFormFactorPtr_t v)
+        __setslice__(vector_IFormFactorPtr_t self, std::vector< IFormFactor * >::difference_type i, std::vector< IFormFactor * >::difference_type j)
         """
         return _libBornAgainCore.vector_IFormFactorPtr_t___setslice__(self, *args)
 
@@ -8930,11 +8867,6 @@ class vector_IFormFactorPtr_t(_object):
         return _libBornAgainCore.vector_IFormFactorPtr_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_IFormFactorPtr_t self) -> IFormFactor"""
-        return _libBornAgainCore.vector_IFormFactorPtr_t_pop(self)
-
-
     def append(self, x):
         """append(vector_IFormFactorPtr_t self, IFormFactor x)"""
         return _libBornAgainCore.vector_IFormFactorPtr_t_append(self, x)
@@ -8950,11 +8882,21 @@ class vector_IFormFactorPtr_t(_object):
         return _libBornAgainCore.vector_IFormFactorPtr_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_IFormFactorPtr_t self)"""
+        return _libBornAgainCore.vector_IFormFactorPtr_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_IFormFactorPtr_t self, vector_IFormFactorPtr_t v)"""
         return _libBornAgainCore.vector_IFormFactorPtr_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_IFormFactorPtr_t self) -> std::vector< IFormFactor * >::allocator_type"""
+        return _libBornAgainCore.vector_IFormFactorPtr_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_IFormFactorPtr_t self) -> std::vector< IFormFactor * >::iterator"""
         return _libBornAgainCore.vector_IFormFactorPtr_t_begin(self)
@@ -8975,16 +8917,6 @@ class vector_IFormFactorPtr_t(_object):
         return _libBornAgainCore.vector_IFormFactorPtr_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_IFormFactorPtr_t self)"""
-        return _libBornAgainCore.vector_IFormFactorPtr_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_IFormFactorPtr_t self) -> std::vector< IFormFactor * >::allocator_type"""
-        return _libBornAgainCore.vector_IFormFactorPtr_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_IFormFactorPtr_t self)"""
         return _libBornAgainCore.vector_IFormFactorPtr_t_pop_back(self)
@@ -9008,7 +8940,7 @@ class vector_IFormFactorPtr_t(_object):
         this = _libBornAgainCore.new_vector_IFormFactorPtr_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -9070,7 +9002,6 @@ class IFormFactorBorn(IFormFactor):
     C++ includes: IFormFactorBorn.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactor]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -9095,7 +9026,7 @@ class IFormFactorBorn(IFormFactor):
         this = _libBornAgainCore.new_IFormFactorBorn(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IFormFactorBorn
     __del__ = lambda self: None
@@ -9193,7 +9124,6 @@ class IFormFactorDecorator(IFormFactor):
     C++ includes: IFormFactorDecorator.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactor]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -9218,7 +9148,7 @@ class IFormFactorDecorator(IFormFactor):
         this = _libBornAgainCore.new_IFormFactorDecorator(_self, form_factor)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IFormFactorDecorator
     __del__ = lambda self: None
@@ -9308,7 +9238,6 @@ class FormFactorAnisoPyramid(IFormFactorBorn):
     C++ includes: FormFactorAnisoPyramid.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -9350,7 +9279,7 @@ class FormFactorAnisoPyramid(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorAnisoPyramid(_self, length, width, height, alpha)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorAnisoPyramid
     __del__ = lambda self: None
@@ -9481,7 +9410,6 @@ class FormFactorBox(IFormFactorBorn):
     C++ includes: FormFactorBox.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -9520,7 +9448,7 @@ class FormFactorBox(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorBox(_self, length, width, height)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -9645,7 +9573,6 @@ class FormFactorCone(IFormFactorBorn):
     C++ includes: FormFactorCone.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -9684,7 +9611,7 @@ class FormFactorCone(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorCone(_self, radius, height, alpha)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorCone
     __del__ = lambda self: None
@@ -9793,7 +9720,6 @@ class FormFactorCone6(IFormFactorBorn):
     C++ includes: FormFactorCone6.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -9832,7 +9758,7 @@ class FormFactorCone6(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorCone6(_self, radius, height, alpha)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorCone6
     __del__ = lambda self: None
@@ -9935,7 +9861,6 @@ class FormFactorCrystal(IFormFactorBorn):
     C++ includes: FormFactorCrystal.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -9960,7 +9885,7 @@ class FormFactorCrystal(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorCrystal(_self, lattice, basis_form_factor, meso_form_factor)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorCrystal
     __del__ = lambda self: None
@@ -10082,7 +10007,6 @@ class FormFactorCuboctahedron(IFormFactorBorn):
     C++ includes: FormFactorCuboctahedron.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -10124,7 +10048,7 @@ class FormFactorCuboctahedron(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorCuboctahedron(_self, length, height, height_ratio, alpha)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorCuboctahedron
     __del__ = lambda self: None
@@ -10253,7 +10177,6 @@ class FormFactorCylinder(IFormFactorBorn):
     C++ includes: FormFactorCylinder.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -10289,7 +10212,7 @@ class FormFactorCylinder(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorCylinder(_self, radius, height)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorCylinder
     __del__ = lambda self: None
@@ -10388,7 +10311,6 @@ class FormFactorDecoratorDebyeWaller(IFormFactorDecorator):
     C++ includes: FormFactorDecoratorDebyeWaller.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorDecorator]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -10416,7 +10338,7 @@ class FormFactorDecoratorDebyeWaller(IFormFactorDecorator):
         this = _libBornAgainCore.new_FormFactorDecoratorDebyeWaller(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorDecoratorDebyeWaller
     __del__ = lambda self: None
@@ -10496,7 +10418,6 @@ class FormFactorEllipsoidalCylinder(IFormFactorBorn):
     C++ includes: FormFactorEllipsoidalCylinder.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -10535,7 +10456,7 @@ class FormFactorEllipsoidalCylinder(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorEllipsoidalCylinder(_self, radius_x, radius_y, height)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -10654,7 +10575,6 @@ class FormFactorFullSphere(IFormFactorBorn):
     C++ includes: FormFactorFullSphere.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -10687,7 +10607,7 @@ class FormFactorFullSphere(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorFullSphere(_self, radius)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -10776,7 +10696,6 @@ class FormFactorFullSpheroid(IFormFactorBorn):
     C++ includes: FormFactorFullSpheroid.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -10812,7 +10731,7 @@ class FormFactorFullSpheroid(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorFullSpheroid(_self, radius, height)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorFullSpheroid
     __del__ = lambda self: None
@@ -10911,7 +10830,6 @@ class FormFactorGauss(IFormFactorBorn):
     C++ includes: FormFactorGauss.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -10937,7 +10855,7 @@ class FormFactorGauss(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorGauss(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorGauss
     __del__ = lambda self: None
@@ -11038,7 +10956,6 @@ class FormFactorHemiEllipsoid(IFormFactorBorn):
     C++ includes: FormFactorHemiEllipsoid.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -11077,7 +10994,7 @@ class FormFactorHemiEllipsoid(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorHemiEllipsoid(_self, radius_x, radius_y, height)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorHemiEllipsoid
     __del__ = lambda self: None
@@ -11188,8 +11105,7 @@ FormFactorHemiEllipsoid_swigregister = _libBornAgainCore.FormFactorHemiEllipsoid
 FormFactorHemiEllipsoid_swigregister(FormFactorHemiEllipsoid)
 
 class FormFactorLongBoxGauss(IFormFactorBorn):
-    """Proxy of C++ FormFactorLongBoxGauss class."""
-
+    """Proxy of C++ FormFactorLongBoxGauss class"""
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -11228,7 +11144,7 @@ class FormFactorLongBoxGauss(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorLongBoxGauss(_self, length, width, height)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -11345,8 +11261,7 @@ FormFactorLongBoxGauss_swigregister = _libBornAgainCore.FormFactorLongBoxGauss_s
 FormFactorLongBoxGauss_swigregister(FormFactorLongBoxGauss)
 
 class FormFactorLongBoxLorentz(IFormFactorBorn):
-    """Proxy of C++ FormFactorLongBoxLorentz class."""
-
+    """Proxy of C++ FormFactorLongBoxLorentz class"""
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -11385,7 +11300,7 @@ class FormFactorLongBoxLorentz(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorLongBoxLorentz(_self, length, width, height)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -11510,7 +11425,6 @@ class FormFactorLorentz(IFormFactorBorn):
     C++ includes: FormFactorLorentz.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -11536,7 +11450,7 @@ class FormFactorLorentz(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorLorentz(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -11649,7 +11563,6 @@ class FormFactorPrism3(IFormFactorBorn):
     C++ includes: FormFactorPrism3.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -11685,7 +11598,7 @@ class FormFactorPrism3(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorPrism3(_self, length, height)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -11794,7 +11707,6 @@ class FormFactorPrism6(IFormFactorBorn):
     C++ includes: FormFactorPrism6.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -11830,7 +11742,7 @@ class FormFactorPrism6(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorPrism6(_self, radius, height)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -11929,7 +11841,6 @@ class FormFactorPyramid(IFormFactorBorn):
     C++ includes: FormFactorPyramid.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -11968,7 +11879,7 @@ class FormFactorPyramid(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorPyramid(_self, length, height, alpha)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorPyramid
     __del__ = lambda self: None
@@ -12087,7 +11998,6 @@ class FormFactorRipple1(IFormFactorBorn):
     C++ includes: FormFactorRipple1.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -12126,7 +12036,7 @@ class FormFactorRipple1(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorRipple1(_self, length, width, height)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorRipple1
     __del__ = lambda self: None
@@ -12239,7 +12149,6 @@ class FormFactorRipple2(IFormFactorBorn):
     C++ includes: FormFactorRipple2.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -12281,7 +12190,7 @@ class FormFactorRipple2(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorRipple2(_self, length, width, height, asymetry)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorRipple2
     __del__ = lambda self: None
@@ -12404,7 +12313,6 @@ class FormFactorSphereGaussianRadius(IFormFactorBorn):
     C++ includes: FormFactorSphereGaussianRadius.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -12429,7 +12337,7 @@ class FormFactorSphereGaussianRadius(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorSphereGaussianRadius(_self, mean, sigma)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -12518,7 +12426,6 @@ class FormFactorSphereLogNormalRadius(IFormFactorBorn):
     C++ includes: FormFactorSphereLogNormalRadius.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -12543,7 +12450,7 @@ class FormFactorSphereLogNormalRadius(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorSphereLogNormalRadius(_self, mean, scale_param, n_samples)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -12632,7 +12539,6 @@ class FormFactorSphereUniformRadius(IFormFactorBorn):
     C++ includes: FormFactorSphereUniformRadius.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -12657,7 +12563,7 @@ class FormFactorSphereUniformRadius(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorSphereUniformRadius(_self, mean, full_width)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -12746,7 +12652,6 @@ class FormFactorTetrahedron(IFormFactorBorn):
     C++ includes: FormFactorTetrahedron.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -12785,7 +12690,7 @@ class FormFactorTetrahedron(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorTetrahedron(_self, length, height, alpha)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorTetrahedron
     __del__ = lambda self: None
@@ -12896,8 +12801,7 @@ FormFactorTetrahedron_swigregister = _libBornAgainCore.FormFactorTetrahedron_swi
 FormFactorTetrahedron_swigregister(FormFactorTetrahedron)
 
 class FormFactorTrivial(IFormFactorBorn):
-    """Proxy of C++ FormFactorTrivial class."""
-
+    """Proxy of C++ FormFactorTrivial class"""
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -12933,7 +12837,7 @@ class FormFactorTrivial(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorTrivial(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -13022,7 +12926,6 @@ class FormFactorTruncatedCube(IFormFactorBorn):
     C++ includes: FormFactorTruncatedCube.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -13058,7 +12961,7 @@ class FormFactorTruncatedCube(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorTruncatedCube(_self, length, removed_length)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -13167,7 +13070,6 @@ class FormFactorTruncatedSphere(IFormFactorBorn):
     C++ includes: FormFactorTruncatedSphere.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -13203,7 +13105,7 @@ class FormFactorTruncatedSphere(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorTruncatedSphere(_self, radius, height)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorTruncatedSphere
     __del__ = lambda self: None
@@ -13302,7 +13204,6 @@ class FormFactorTruncatedSpheroid(IFormFactorBorn):
     C++ includes: FormFactorTruncatedSpheroid.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactorBorn]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -13341,7 +13242,7 @@ class FormFactorTruncatedSpheroid(IFormFactorBorn):
         this = _libBornAgainCore.new_FormFactorTruncatedSpheroid(_self, radius, height, height_flattening)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorTruncatedSpheroid
     __del__ = lambda self: None
@@ -13450,7 +13351,6 @@ class FormFactorWeighted(IFormFactor):
     C++ includes: FormFactorWeighted.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFormFactor]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -13475,7 +13375,7 @@ class FormFactorWeighted(IFormFactor):
         this = _libBornAgainCore.new_FormFactorWeighted(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_FormFactorWeighted
     __del__ = lambda self: None
@@ -13587,7 +13487,6 @@ class Simulation(ICloneable, IParameterized):
     C++ includes: GISASSimulation.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ICloneable, IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -13829,7 +13728,7 @@ class Simulation(ICloneable, IParameterized):
         this = _libBornAgainCore.new_Simulation(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def init_parameters(self):
@@ -13864,8 +13763,7 @@ Simulation_swigregister = _libBornAgainCore.Simulation_swigregister
 Simulation_swigregister(Simulation)
 
 class SimulationParameters(_object):
-    """Proxy of C++ SimulationParameters class."""
-
+    """Proxy of C++ SimulationParameters class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, SimulationParameters, name, value)
     __swig_getmethods__ = {}
@@ -13882,7 +13780,7 @@ class SimulationParameters(_object):
         this = _libBornAgainCore.new_SimulationParameters()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_setmethods__["m_mc_integration"] = _libBornAgainCore.SimulationParameters_m_mc_integration_set
     __swig_getmethods__["m_mc_integration"] = _libBornAgainCore.SimulationParameters_m_mc_integration_get
@@ -13898,8 +13796,7 @@ SimulationParameters_swigregister = _libBornAgainCore.SimulationParameters_swigr
 SimulationParameters_swigregister(SimulationParameters)
 
 class GISASSimulation(Simulation):
-    """Proxy of C++ GISASSimulation class."""
-
+    """Proxy of C++ GISASSimulation class"""
     __swig_setmethods__ = {}
     for _s in [Simulation]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -14206,7 +14103,7 @@ class GISASSimulation(Simulation):
         this = _libBornAgainCore.new_GISASSimulation(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def init_parameters(self):
@@ -14249,7 +14146,6 @@ class IHistogram(_object):
     C++ includes: IHistogram.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, IHistogram, name, value)
     __swig_getmethods__ = {}
@@ -14279,7 +14175,7 @@ class IHistogram(_object):
         this = _libBornAgainCore.new_IHistogram(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -14811,8 +14707,7 @@ def IHistogram_createFrom(filename):
     return _libBornAgainCore.IHistogram_createFrom(filename)
 
 class Histogram1D(IHistogram):
-    """Proxy of C++ Histogram1D class."""
-
+    """Proxy of C++ Histogram1D class"""
     __swig_setmethods__ = {}
     for _s in [IHistogram]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -14842,7 +14737,7 @@ class Histogram1D(IHistogram):
         this = _libBornAgainCore.new_Histogram1D(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -14954,8 +14849,7 @@ Histogram1D_swigregister = _libBornAgainCore.Histogram1D_swigregister
 Histogram1D_swigregister(Histogram1D)
 
 class Histogram2D(IHistogram):
-    """Proxy of C++ Histogram2D class."""
-
+    """Proxy of C++ Histogram2D class"""
     __swig_setmethods__ = {}
     for _s in [IHistogram]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -14985,7 +14879,7 @@ class Histogram2D(IHistogram):
         this = _libBornAgainCore.new_Histogram2D(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -15100,7 +14994,6 @@ class IMaterial(INamed):
     C++ includes: IMaterial.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [INamed]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -15127,7 +15020,7 @@ class IMaterial(INamed):
         this = _libBornAgainCore.new_IMaterial(_self, name)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IMaterial
     __del__ = lambda self: None
@@ -15200,7 +15093,6 @@ class HomogeneousMaterial(IMaterial):
     C++ includes: HomogeneousMaterial.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IMaterial]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -15228,7 +15120,7 @@ class HomogeneousMaterial(IMaterial):
         this = _libBornAgainCore.new_HomogeneousMaterial(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_HomogeneousMaterial
     __del__ = lambda self: None
@@ -15301,7 +15193,6 @@ class HomogeneousMagneticMaterial(HomogeneousMaterial):
     C++ includes: HomogeneousMagneticMaterial.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [HomogeneousMaterial]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -15329,7 +15220,7 @@ class HomogeneousMagneticMaterial(HomogeneousMaterial):
         this = _libBornAgainCore.new_HomogeneousMagneticMaterial(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -15406,8 +15297,7 @@ HomogeneousMagneticMaterial_swigregister = _libBornAgainCore.HomogeneousMagnetic
 HomogeneousMagneticMaterial_swigregister(HomogeneousMagneticMaterial)
 
 class IDetector2D(IParameterized):
-    """Proxy of C++ IDetector2D class."""
-
+    """Proxy of C++ IDetector2D class"""
     __swig_setmethods__ = {}
     for _s in [IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -15439,7 +15329,7 @@ class IDetector2D(IParameterized):
         this = _libBornAgainCore.new_IDetector2D(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -15763,7 +15653,6 @@ class IDetectorResolution(ICloneable, IParameterized):
     C++ includes: IDetectorResolution.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ICloneable, IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -15816,7 +15705,7 @@ class IDetectorResolution(ICloneable, IParameterized):
         this = _libBornAgainCore.new_IDetectorResolution(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -15844,7 +15733,6 @@ class IInterferenceFunction(ISample):
     C++ includes: IInterferenceFunction.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ISample]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -15935,7 +15823,7 @@ class IInterferenceFunction(ISample):
         this = _libBornAgainCore.new_IInterferenceFunction(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -15963,7 +15851,6 @@ class ILayout(ICompositeSample):
     C++ includes: ILayout.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ICompositeSample]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -15990,7 +15877,7 @@ class ILayout(ICompositeSample):
         this = _libBornAgainCore.new_ILayout(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_ILayout
     __del__ = lambda self: None
@@ -16176,7 +16063,6 @@ class IObserver(_object):
     C++ includes: IObserver.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, IObserver, name, value)
     __swig_getmethods__ = {}
@@ -16215,7 +16101,7 @@ class IObserver(_object):
         this = _libBornAgainCore.new_IObserver(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -16233,7 +16119,6 @@ class IObservable(_object):
     C++ includes: IObserver.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, IObservable, name, value)
     __swig_getmethods__ = {}
@@ -16284,7 +16169,7 @@ class IObservable(_object):
         this = _libBornAgainCore.new_IObservable(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -16302,7 +16187,6 @@ class IAbstractParticle(ICompositeSample):
     C++ includes: IParticle.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ICompositeSample]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -16327,7 +16211,7 @@ class IAbstractParticle(ICompositeSample):
         this = _libBornAgainCore.new_IAbstractParticle(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IAbstractParticle
     __del__ = lambda self: None
@@ -16441,7 +16325,6 @@ class IParticle(IAbstractParticle):
     C++ includes: IParticle.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IAbstractParticle]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -16605,7 +16488,7 @@ class IParticle(IAbstractParticle):
         this = _libBornAgainCore.new_IParticle(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -16633,7 +16516,6 @@ class IResolutionFunction2D(IParameterized):
     C++ includes: IResolutionFunction2D.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -16684,7 +16566,7 @@ class IResolutionFunction2D(IParameterized):
         this = _libBornAgainCore.new_IResolutionFunction2D(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -16712,7 +16594,6 @@ class IRotation(ISample):
     C++ includes: Rotations.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ISample]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -16823,7 +16704,7 @@ class IRotation(ISample):
         this = _libBornAgainCore.new_IRotation(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -16856,8 +16737,7 @@ def CreateProduct(left, right):
     """
     return _libBornAgainCore.CreateProduct(left, right)
 class RotationX(IRotation):
-    """Proxy of C++ RotationX class."""
-
+    """Proxy of C++ RotationX class"""
     __swig_setmethods__ = {}
     for _s in [IRotation]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -16882,7 +16762,7 @@ class RotationX(IRotation):
         this = _libBornAgainCore.new_RotationX(_self, angle)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -16974,8 +16854,7 @@ RotationX_swigregister = _libBornAgainCore.RotationX_swigregister
 RotationX_swigregister(RotationX)
 
 class RotationY(IRotation):
-    """Proxy of C++ RotationY class."""
-
+    """Proxy of C++ RotationY class"""
     __swig_setmethods__ = {}
     for _s in [IRotation]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -17000,7 +16879,7 @@ class RotationY(IRotation):
         this = _libBornAgainCore.new_RotationY(_self, angle)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -17092,8 +16971,7 @@ RotationY_swigregister = _libBornAgainCore.RotationY_swigregister
 RotationY_swigregister(RotationY)
 
 class RotationZ(IRotation):
-    """Proxy of C++ RotationZ class."""
-
+    """Proxy of C++ RotationZ class"""
     __swig_setmethods__ = {}
     for _s in [IRotation]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -17119,7 +16997,7 @@ class RotationZ(IRotation):
         this = _libBornAgainCore.new_RotationZ(_self, angle)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -17211,8 +17089,7 @@ RotationZ_swigregister = _libBornAgainCore.RotationZ_swigregister
 RotationZ_swigregister(RotationZ)
 
 class RotationEuler(IRotation):
-    """Proxy of C++ RotationEuler class."""
-
+    """Proxy of C++ RotationEuler class"""
     __swig_setmethods__ = {}
     for _s in [IRotation]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -17237,7 +17114,7 @@ class RotationEuler(IRotation):
         this = _libBornAgainCore.new_RotationEuler(_self, alpha, beta, gamma)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -17357,7 +17234,6 @@ class ISelectionRule(_object):
     C++ includes: ISelectionRule.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, ISelectionRule, name, value)
     __swig_getmethods__ = {}
@@ -17404,7 +17280,7 @@ class ISelectionRule(_object):
         this = _libBornAgainCore.new_ISelectionRule(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -17422,7 +17298,6 @@ class SimpleSelectionRule(ISelectionRule):
     C++ includes: ISelectionRule.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ISelectionRule]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -17447,7 +17322,7 @@ class SimpleSelectionRule(ISelectionRule):
         this = _libBornAgainCore.new_SimpleSelectionRule(_self, a, b, c, modulus)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_SimpleSelectionRule
     __del__ = lambda self: None
@@ -17487,7 +17362,6 @@ class Instrument(IParameterized):
     C++ includes: Instrument.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -17513,7 +17387,7 @@ class Instrument(IParameterized):
         this = _libBornAgainCore.new_Instrument(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_Instrument
     __del__ = lambda self: None
@@ -17771,7 +17645,6 @@ class IntensityDataFunctions(_object):
     C++ includes: IntensityDataFunctions.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, IntensityDataFunctions, name, value)
     __swig_getmethods__ = {}
@@ -17819,7 +17692,7 @@ class IntensityDataFunctions(_object):
         this = _libBornAgainCore.new_IntensityDataFunctions()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IntensityDataFunctions
     __del__ = lambda self: None
@@ -17852,7 +17725,6 @@ class IntensityDataIOFactory(_object):
     C++ includes: IntensityDataIOFactory.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, IntensityDataIOFactory, name, value)
     __swig_getmethods__ = {}
@@ -17907,7 +17779,7 @@ class IntensityDataIOFactory(_object):
         this = _libBornAgainCore.new_IntensityDataIOFactory()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IntensityDataIOFactory
     __del__ = lambda self: None
@@ -17939,7 +17811,6 @@ class InterferenceFunction1DLattice(IInterferenceFunction):
     C++ includes: InterferenceFunction1DLattice.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IInterferenceFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -17978,7 +17849,7 @@ class InterferenceFunction1DLattice(IInterferenceFunction):
         this = _libBornAgainCore.new_InterferenceFunction1DLattice(_self, length, xi)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_InterferenceFunction1DLattice
     __del__ = lambda self: None
@@ -18074,7 +17945,6 @@ class InterferenceFunctionRadialParaCrystal(IInterferenceFunction):
     C++ includes: InterferenceFunctionRadialParaCrystal.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IInterferenceFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -18114,7 +17984,7 @@ class InterferenceFunctionRadialParaCrystal(IInterferenceFunction):
         this = _libBornAgainCore.new_InterferenceFunctionRadialParaCrystal(_self, peak_distance, damping_length)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_InterferenceFunctionRadialParaCrystal
     __del__ = lambda self: None
@@ -18298,7 +18168,6 @@ class InterferenceFunction2DLattice(IInterferenceFunction):
     C++ includes: InterferenceFunction2DLattice.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IInterferenceFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -18341,7 +18210,7 @@ class InterferenceFunction2DLattice(IInterferenceFunction):
         this = _libBornAgainCore.new_InterferenceFunction2DLattice(_self, length_1, length_2, angle, xi)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_InterferenceFunction2DLattice
     __del__ = lambda self: None
@@ -18498,7 +18367,6 @@ class InterferenceFunction2DParaCrystal(IInterferenceFunction):
     C++ includes: InterferenceFunction2DParaCrystal.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IInterferenceFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -18545,7 +18413,7 @@ class InterferenceFunction2DParaCrystal(IInterferenceFunction):
         this = _libBornAgainCore.new_InterferenceFunction2DParaCrystal(_self, length_1, length_2, alpha_lattice, xi, damping_length)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_InterferenceFunction2DParaCrystal
     __del__ = lambda self: None
@@ -18782,7 +18650,6 @@ class InterferenceFunctionNone(IInterferenceFunction):
     C++ includes: InterferenceFunctionNone.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IInterferenceFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -18807,7 +18674,7 @@ class InterferenceFunctionNone(IInterferenceFunction):
         this = _libBornAgainCore.new_InterferenceFunctionNone(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -18873,7 +18740,6 @@ class IPixelMap(_object):
     C++ includes: IPixelMap.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, IPixelMap, name, value)
     __swig_getmethods__ = {}
@@ -18950,7 +18816,7 @@ class IPixelMap(_object):
         this = _libBornAgainCore.new_IPixelMap(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -18968,7 +18834,6 @@ class SphericalDetector(IDetector2D):
     C++ includes: SphericalDetector.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IDetector2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -18995,7 +18860,7 @@ class SphericalDetector(IDetector2D):
         this = _libBornAgainCore.new_SphericalDetector(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -19091,8 +18956,7 @@ SphericalDetector_swigregister = _libBornAgainCore.SphericalDetector_swigregiste
 SphericalDetector_swigregister(SphericalDetector)
 
 class AngularPixelMap(IPixelMap):
-    """Proxy of C++ AngularPixelMap class."""
-
+    """Proxy of C++ AngularPixelMap class"""
     __swig_setmethods__ = {}
     for _s in [IPixelMap]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -19117,7 +18981,7 @@ class AngularPixelMap(IPixelMap):
         this = _libBornAgainCore.new_AngularPixelMap(_self, alpha_bin, phi_bin)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_AngularPixelMap
     __del__ = lambda self: None
@@ -19187,7 +19051,6 @@ class IsGISAXSDetector(SphericalDetector):
     C++ includes: IsGISAXSDetector.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [SphericalDetector]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -19214,7 +19077,7 @@ class IsGISAXSDetector(SphericalDetector):
         this = _libBornAgainCore.new_IsGISAXSDetector(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -19269,7 +19132,6 @@ class Lattice(_object):
     C++ includes: Lattice.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, Lattice, name, value)
     __swig_getmethods__ = {}
@@ -19288,7 +19150,7 @@ class Lattice(_object):
         this = _libBornAgainCore.new_Lattice(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_Lattice
     __del__ = lambda self: None
@@ -19470,7 +19332,6 @@ class Lattice1DParameters(_object):
     C++ includes: Lattice1DParameters.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, Lattice1DParameters, name, value)
     __swig_getmethods__ = {}
@@ -19487,7 +19348,7 @@ class Lattice1DParameters(_object):
         this = _libBornAgainCore.new_Lattice1DParameters()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_setmethods__["m_length"] = _libBornAgainCore.Lattice1DParameters_m_length_set
     __swig_getmethods__["m_length"] = _libBornAgainCore.Lattice1DParameters_m_length_get
@@ -19511,7 +19372,6 @@ class Lattice2DParameters(_object):
     C++ includes: Lattice2DParameters.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, Lattice2DParameters, name, value)
     __swig_getmethods__ = {}
@@ -19528,7 +19388,7 @@ class Lattice2DParameters(_object):
         this = _libBornAgainCore.new_Lattice2DParameters()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_setmethods__["m_length_1"] = _libBornAgainCore.Lattice2DParameters_m_length_1_set
     __swig_getmethods__["m_length_1"] = _libBornAgainCore.Lattice2DParameters_m_length_1_get
@@ -19569,7 +19429,6 @@ class Layer(ICompositeSample):
     C++ includes: Layer.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ICompositeSample]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -19821,7 +19680,7 @@ class Layer(ICompositeSample):
         this = _libBornAgainCore.new_Layer(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def init_parameters(self):
@@ -19854,7 +19713,6 @@ class IRoughness(ISample):
     C++ includes: IRoughness.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ISample]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -19879,7 +19737,7 @@ class IRoughness(ISample):
         this = _libBornAgainCore.new_IRoughness(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IRoughness
     __del__ = lambda self: None
@@ -19923,7 +19781,6 @@ class LayerRoughness(IRoughness):
     C++ includes: LayerRoughness.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IRoughness]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -19949,7 +19806,7 @@ class LayerRoughness(IRoughness):
         this = _libBornAgainCore.new_LayerRoughness(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -20103,7 +19960,6 @@ class Line(IShape2D):
     C++ includes: Line.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IShape2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -20130,7 +19986,7 @@ class Line(IShape2D):
         this = _libBornAgainCore.new_Line(_self, x1, y1, x2, y2)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -20178,7 +20034,6 @@ class VerticalLine(IShape2D):
     C++ includes: Line.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IShape2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -20211,7 +20066,7 @@ class VerticalLine(IShape2D):
         this = _libBornAgainCore.new_VerticalLine(_self, x)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -20269,7 +20124,6 @@ class HorizontalLine(IShape2D):
     C++ includes: Line.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IShape2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -20302,7 +20156,7 @@ class HorizontalLine(IShape2D):
         this = _libBornAgainCore.new_HorizontalLine(_self, y)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -20540,7 +20394,6 @@ class MesoCrystal(IParticle):
     C++ includes: MesoCrystal.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IParticle]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -20565,7 +20418,7 @@ class MesoCrystal(IParticle):
         this = _libBornAgainCore.new_MesoCrystal(_self, particle_structure, form_factor)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_MesoCrystal
     __del__ = lambda self: None
@@ -20700,7 +20553,6 @@ class Logger(_object):
     C++ includes: MessageService.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, Logger, name, value)
     __swig_getmethods__ = {}
@@ -20717,7 +20569,7 @@ class Logger(_object):
         this = _libBornAgainCore.new_Logger(level)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_Logger
     __del__ = lambda self: None
@@ -20797,7 +20649,6 @@ class MultiLayer(ICompositeSample):
     C++ includes: MultiLayer.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ICompositeSample]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -20822,7 +20673,7 @@ class MultiLayer(ICompositeSample):
         this = _libBornAgainCore.new_MultiLayer(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_MultiLayer
     __del__ = lambda self: None
@@ -21126,7 +20977,6 @@ class OffSpecSimulation(Simulation):
     C++ includes: OffSpecSimulation.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [Simulation]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -21353,7 +21203,7 @@ class OffSpecSimulation(Simulation):
         this = _libBornAgainCore.new_OffSpecSimulation(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def init_parameters(self):
@@ -21396,7 +21246,6 @@ class IntensityData(_object):
     C++ includes: OutputData.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, IntensityData, name, value)
     __swig_getmethods__ = {}
@@ -21413,7 +21262,7 @@ class IntensityData(_object):
         this = _libBornAgainCore.new_IntensityData()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_IntensityData
     __del__ = lambda self: None
@@ -22001,8 +21850,7 @@ def applyFunction(data, func):
     """
     return _libBornAgainCore.applyFunction(data, func)
 class ParameterDistribution(IParameterized):
-    """Proxy of C++ ParameterDistribution class."""
-
+    """Proxy of C++ ParameterDistribution class"""
     __swig_setmethods__ = {}
     for _s in [IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -22031,7 +21879,7 @@ class ParameterDistribution(IParameterized):
         this = _libBornAgainCore.new_ParameterDistribution(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_ParameterDistribution
     __del__ = lambda self: None
@@ -22171,7 +22019,6 @@ class ParameterPool(ICloneable):
     C++ includes: ParameterPool.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ICloneable]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -22198,7 +22045,7 @@ class ParameterPool(ICloneable):
         this = _libBornAgainCore.new_ParameterPool(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_ParameterPool
     __del__ = lambda self: None
@@ -22380,7 +22227,6 @@ class Particle(IParticle):
     C++ includes: Particle.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IParticle]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -22408,7 +22254,7 @@ class Particle(IParticle):
         this = _libBornAgainCore.new_Particle(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -22570,7 +22416,6 @@ class ParticleComposition(IParticle):
     C++ includes: ParticleComposition.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IParticle]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -22598,7 +22443,7 @@ class ParticleComposition(IParticle):
         this = _libBornAgainCore.new_ParticleComposition(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_ParticleComposition
     __del__ = lambda self: None
@@ -22755,7 +22600,6 @@ class ParticleCoreShell(IParticle):
     C++ includes: ParticleCoreShell.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IParticle]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -22880,7 +22724,7 @@ class ParticleCoreShell(IParticle):
         this = _libBornAgainCore.new_ParticleCoreShell(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -22908,7 +22752,6 @@ class ParticleDistribution(IAbstractParticle):
     C++ includes: ParticleDistribution.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IAbstractParticle]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -22933,7 +22776,7 @@ class ParticleDistribution(IAbstractParticle):
         this = _libBornAgainCore.new_ParticleDistribution(_self, prototype, par_distr)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -23071,7 +22914,6 @@ class ParticleLayout(ILayout):
     C++ includes: ParticleLayout.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ILayout]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -23098,7 +22940,7 @@ class ParticleLayout(ILayout):
         this = _libBornAgainCore.new_ParticleLayout(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_ParticleLayout
     __del__ = lambda self: None
@@ -23291,7 +23133,6 @@ class Polygon(IShape2D):
     C++ includes: Polygon.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IShape2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -23325,7 +23166,7 @@ class Polygon(IShape2D):
         this = _libBornAgainCore.new_Polygon(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_Polygon
     __del__ = lambda self: None
@@ -23393,7 +23234,6 @@ class RealParameterWrapper(_object):
     C++ includes: RealParameterWrapper.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, RealParameterWrapper, name, value)
     __swig_getmethods__ = {}
@@ -23412,7 +23252,7 @@ class RealParameterWrapper(_object):
         this = _libBornAgainCore.new_RealParameterWrapper(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_RealParameterWrapper
     __del__ = lambda self: None
@@ -23496,7 +23336,6 @@ class Rectangle(IShape2D):
     C++ includes: Rectangle.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IShape2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -23538,7 +23377,7 @@ class Rectangle(IShape2D):
         this = _libBornAgainCore.new_Rectangle(_self, xlow, ylow, xup, yup)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -23636,7 +23475,6 @@ class RectangularDetector(IDetector2D):
     C++ includes: RectangularDetector.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IDetector2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -23667,7 +23505,7 @@ class RectangularDetector(IDetector2D):
         this = _libBornAgainCore.new_RectangularDetector(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -23948,8 +23786,7 @@ RectangularDetector_swigregister = _libBornAgainCore.RectangularDetector_swigreg
 RectangularDetector_swigregister(RectangularDetector)
 
 class RectPixelMap(IPixelMap):
-    """Proxy of C++ RectPixelMap class."""
-
+    """Proxy of C++ RectPixelMap class"""
     __swig_setmethods__ = {}
     for _s in [IPixelMap]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -23974,7 +23811,7 @@ class RectPixelMap(IPixelMap):
         this = _libBornAgainCore.new_RectPixelMap(_self, corner_pos, width, height)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainCore.delete_RectPixelMap
     __del__ = lambda self: None
@@ -24044,7 +23881,6 @@ class ResolutionFunction2DGaussian(IResolutionFunction2D):
     C++ includes: ResolutionFunction2DGaussian.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IResolutionFunction2D]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -24069,7 +23905,7 @@ class ResolutionFunction2DGaussian(IResolutionFunction2D):
         this = _libBornAgainCore.new_ResolutionFunction2DGaussian(_self, sigma_x, sigma_y)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def evaluateCDF(self, x, y):
@@ -24139,7 +23975,6 @@ class SpecularSimulation(ICloneable, IParameterized):
     C++ includes: SpecularSimulation.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [ICloneable, IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -24331,7 +24166,7 @@ class SpecularSimulation(ICloneable, IParameterized):
         this = _libBornAgainCore.new_SpecularSimulation(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def init_parameters(self):
@@ -24359,7 +24194,6 @@ class ThreadInfo(_object):
     C++ includes: ThreadInfo.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, ThreadInfo, name, value)
     __swig_getmethods__ = {}
@@ -24376,7 +24210,7 @@ class ThreadInfo(_object):
         this = _libBornAgainCore.new_ThreadInfo()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_setmethods__["n_threads"] = _libBornAgainCore.ThreadInfo_n_threads_set
     __swig_getmethods__["n_threads"] = _libBornAgainCore.ThreadInfo_n_threads_get
diff --git a/Core/PythonAPI/libBornAgainCore_wrap.cxx b/Core/PythonAPI/libBornAgainCore_wrap.cxx
index 0f012c10d0c0e600e9cc11f4f401c603ec17baf1..9f4ab700a21220a3dbe4fda2f3165beb90313399 100644
--- a/Core/PythonAPI/libBornAgainCore_wrap.cxx
+++ b/Core/PythonAPI/libBornAgainCore_wrap.cxx
@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 3.0.8
+ * Version 3.0.7
  *
  * This file is not intended to be easily readable and contains a number of
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -8,11 +8,7 @@
  * interface file instead.
  * ----------------------------------------------------------------------------- */
 
-
-#ifndef SWIGPYTHON
 #define SWIGPYTHON
-#endif
-
 #define SWIG_DIRECTORS
 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
 
@@ -1330,7 +1326,7 @@ SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
 
 /* Unpack the argument tuple */
 
-SWIGINTERN Py_ssize_t
+SWIGINTERN int
 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
 {
   if (!args) {
@@ -1344,7 +1340,7 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssi
   }  
   if (!PyTuple_Check(args)) {
     if (min <= 1 && max >= 1) {
-      Py_ssize_t i;
+      int i;
       objs[0] = args;
       for (i = 1; i < max; ++i) {
 	objs[i] = 0;
@@ -1364,7 +1360,7 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssi
 		   name, (min == max ? "" : "at most "), (int)max, (int)l);
       return 0;
     } else {
-      Py_ssize_t i;
+      int i;
       for (i = 0; i < l; ++i) {
 	objs[i] = PyTuple_GET_ITEM(args, i);
       }
@@ -1705,32 +1701,16 @@ SwigPyObject_dealloc(PyObject *v)
     if (destroy) {
       /* destroy is always a VARARGS method */
       PyObject *res;
-
-      /* PyObject_CallFunction() has the potential to silently drop
-         the active active exception.  In cases of unnamed temporary
-         variable or where we just finished iterating over a generator
-         StopIteration will be active right now, and this needs to
-         remain true upon return from SwigPyObject_dealloc.  So save
-         and restore. */
-      
-      PyObject *val = NULL, *type = NULL, *tb = NULL;
-      PyErr_Fetch(&val, &type, &tb);
-
       if (data->delargs) {
-        /* we need to create a temporary object to carry the destroy operation */
-        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
-        res = SWIG_Python_CallFunctor(destroy, tmp);
-        Py_DECREF(tmp);
+	/* we need to create a temporary object to carry the destroy operation */
+	PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
+	res = SWIG_Python_CallFunctor(destroy, tmp);
+	Py_DECREF(tmp);
       } else {
-        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
-        PyObject *mself = PyCFunction_GET_SELF(destroy);
-        res = ((*meth)(mself, v));
+	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
+	PyObject *mself = PyCFunction_GET_SELF(destroy);
+	res = ((*meth)(mself, v));
       }
-      if (!res)
-        PyErr_WriteUnraisable(destroy);
-
-      PyErr_Restore(val, type, tb);
-
       Py_XDECREF(res);
     } 
 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
@@ -1754,7 +1734,6 @@ SwigPyObject_append(PyObject* v, PyObject* next)
   next = tmp;
 #endif
   if (!SwigPyObject_Check(next)) {
-    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
     return NULL;
   }
   sobj->next = next;
@@ -1910,9 +1889,7 @@ SwigPyObject_TypeOnce(void) {
     (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
     (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
 #endif
-#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
-#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
+#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
@@ -1992,19 +1969,10 @@ SwigPyObject_TypeOnce(void) {
       0,                                    /* tp_del */
 #endif
 #if PY_VERSION_HEX >= 0x02060000
-      0,                                    /* tp_version_tag */
-#endif
-#if PY_VERSION_HEX >= 0x03040000
-      0,                                    /* tp_finalize */
+      0,                                    /* tp_version */
 #endif
 #ifdef COUNT_ALLOCS
-      0,                                    /* tp_allocs */
-      0,                                    /* tp_frees */
-      0,                                    /* tp_maxalloc */
-#if PY_VERSION_HEX >= 0x02050000
-      0,                                    /* tp_prev */
-#endif
-      0                                     /* tp_next */
+      0,0,0,0                               /* tp_alloc -> tp_next */
 #endif
     };
     swigpyobject_type = tmp;
@@ -2180,19 +2148,10 @@ SwigPyPacked_TypeOnce(void) {
       0,                                    /* tp_del */
 #endif
 #if PY_VERSION_HEX >= 0x02060000
-      0,                                    /* tp_version_tag */
-#endif
-#if PY_VERSION_HEX >= 0x03040000
-      0,                                    /* tp_finalize */
+      0,                                    /* tp_version */
 #endif
 #ifdef COUNT_ALLOCS
-      0,                                    /* tp_allocs */
-      0,                                    /* tp_frees */
-      0,                                    /* tp_maxalloc */
-#if PY_VERSION_HEX >= 0x02050000
-      0,                                    /* tp_prev */
-#endif
-      0                                     /* tp_next */
+      0,0,0,0                               /* tp_alloc -> tp_next */
 #endif
     };
     swigpypacked_type = tmp;
@@ -2720,11 +2679,13 @@ PyModule_AddObject(PyObject *m, char *name, PyObject *o)
 {
   PyObject *dict;
   if (!PyModule_Check(m)) {
-    PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
+    PyErr_SetString(PyExc_TypeError,
+		    "PyModule_AddObject() needs module as first arg");
     return SWIG_ERROR;
   }
   if (!o) {
-    PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
+    PyErr_SetString(PyExc_TypeError,
+		    "PyModule_AddObject() needs non-NULL value");
     return SWIG_ERROR;
   }
   
@@ -3716,7 +3677,7 @@ static swig_module_info swig_module = {swig_types, 237, 0, 0, 0, 0};
 #endif
 #define SWIG_name    "_libBornAgainCore"
 
-#define SWIGVERSION 0x030008 
+#define SWIGVERSION 0x030007 
 #define SWIG_VERSION SWIGVERSION
 
 
@@ -3959,11 +3920,9 @@ SWIG_AsVal_double (PyObject *obj, double *val)
   if (PyFloat_Check(obj)) {
     if (val) *val = PyFloat_AsDouble(obj);
     return SWIG_OK;
-#if PY_VERSION_HEX < 0x03000000
   } else if (PyInt_Check(obj)) {
     if (val) *val = PyInt_AsLong(obj);
     return SWIG_OK;
-#endif
   } else if (PyLong_Check(obj)) {
     double v = PyLong_AsDouble(obj);
     if (!PyErr_Occurred()) {
@@ -4055,7 +4014,18 @@ SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
       return SWIG_OK;
     } else {
       PyErr_Clear();
-      return SWIG_OverflowError;
+#if PY_VERSION_HEX >= 0x03000000
+      {
+        long v = PyLong_AsLong(obj);
+        if (!PyErr_Occurred()) {
+          if (v < 0) {
+            return SWIG_OverflowError;
+          }
+        } else {
+          PyErr_Clear();
+        }
+      }
+#endif
     }
   }
 #ifdef SWIG_PYTHON_CAST_MODE
@@ -4112,20 +4082,16 @@ SWIGINTERNINLINE PyObject*
 SWIGINTERN int
 SWIG_AsVal_long (PyObject *obj, long* val)
 {
-#if PY_VERSION_HEX < 0x03000000
   if (PyInt_Check(obj)) {
     if (val) *val = PyInt_AsLong(obj);
     return SWIG_OK;
-  } else
-#endif
-  if (PyLong_Check(obj)) {
+  } else if (PyLong_Check(obj)) {
     long v = PyLong_AsLong(obj);
     if (!PyErr_Occurred()) {
       if (val) *val = v;
       return SWIG_OK;
     } else {
       PyErr_Clear();
-      return SWIG_OverflowError;
     }
   }
 #ifdef SWIG_PYTHON_CAST_MODE
@@ -4175,7 +4141,7 @@ SWIGINTERNINLINE PyObject*
 }
 
 
-namespace swig {
+namespace swig {  
   template <class Type>
   struct noconst_traits {
     typedef Type noconst_type;
@@ -4189,7 +4155,7 @@ namespace swig {
   /*
     type categories
   */
-  struct pointer_category { };
+  struct pointer_category { };  
   struct value_category { };
 
   /*
@@ -4202,12 +4168,12 @@ namespace swig {
     return traits<typename noconst_traits<Type >::noconst_type >::type_name();
   }
 
-  template <class Type>
+  template <class Type> 
   struct traits_info {
     static swig_type_info *type_query(std::string name) {
       name += " *";
       return SWIG_TypeQuery(name.c_str());
-    }
+    }    
     static swig_type_info *type_info() {
       static swig_type_info *info = type_query(type_name<Type>());
       return info;
@@ -4228,17 +4194,17 @@ namespace swig {
       std::string ptrname = name;
       ptrname += " *";
       return ptrname;
-    }
+    }    
     static const char* type_name() {
       static std::string name = make_ptr_name(swig::type_name<Type>());
       return name.c_str();
     }
   };
 
-  template <class Type, class Category>
+  template <class Type, class Category> 
   struct traits_as { };
-
-  template <class Type, class Category>
+ 
+  template <class Type, class Category> 
   struct traits_check { };
 
 }
@@ -4582,12 +4548,6 @@ namespace swig {
     return pos;
   }
 
-  template <class Sequence>
-  inline void
-  erase(Sequence* seq, const typename Sequence::iterator& position) {
-    seq->erase(position);
-  }
-
   template <class Sequence, class Difference>
   inline Sequence*
   getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
@@ -4962,7 +4922,7 @@ namespace swig
   template <class T>
   struct SwigPySequence_Ref
   {
-    SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
+    SwigPySequence_Ref(PyObject* seq, int index)
       : _seq(seq), _index(index)
     {
     }
@@ -4974,7 +4934,7 @@ namespace swig
 	return swig::as<T>(item, true);
       } catch (std::exception& e) {
 	char msg[1024];
-	sprintf(msg, "in sequence element %d ", (int)_index);
+	sprintf(msg, "in sequence element %d ", _index);
 	if (!PyErr_Occurred()) {
 	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
 	}
@@ -4992,7 +4952,7 @@ namespace swig
 
   private:
     PyObject* _seq;
-    Py_ssize_t _index;
+    int _index;
   };
 
   template <class T>
@@ -5013,13 +4973,13 @@ namespace swig
     typedef Reference reference;
     typedef T value_type;
     typedef T* pointer;
-    typedef Py_ssize_t difference_type;
+    typedef int difference_type;
 
     SwigPySequence_InputIterator()
     {
     }
 
-    SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
+    SwigPySequence_InputIterator(PyObject* seq, int index)
       : _seq(seq), _index(index)
     {
     }
@@ -5099,7 +5059,6 @@ namespace swig
     difference_type _index;
   };
 
-  // STL container wrapper around a Python sequence
   template <class T>
   struct SwigPySequence_Cont
   {
@@ -5107,8 +5066,8 @@ namespace swig
     typedef const SwigPySequence_Ref<T> const_reference;
     typedef T value_type;
     typedef T* pointer;
-    typedef Py_ssize_t difference_type;
-    typedef size_t size_type;
+    typedef int difference_type;
+    typedef int size_type;
     typedef const pointer const_pointer;
     typedef SwigPySequence_InputIterator<T, reference> iterator;
     typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;
@@ -5169,13 +5128,13 @@ namespace swig
 
     bool check(bool set_err = true) const
     {
-      Py_ssize_t s = size();
-      for (Py_ssize_t i = 0; i < s; ++i) {
+      int s = size();
+      for (int i = 0; i < s; ++i) {
 	swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
 	if (!swig::check<value_type>(item)) {
 	  if (set_err) {
 	    char msg[1024];
-	    sprintf(msg, "in sequence element %d", (int)i);
+	    sprintf(msg, "in sequence element %d", i);
 	    SWIG_Error(SWIG_RuntimeError, msg);
 	  }
 	  return false;
@@ -5195,17 +5154,17 @@ namespace swig
 
 
 namespace swig {
-  template <> struct traits< double > {
+  template <> struct traits<double > {
     typedef value_category category;
     static const char* type_name() { return"double"; }
-  };
-  template <>  struct traits_asval< double > {
+  };  
+  template <>  struct traits_asval<double > {   
     typedef double value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_double (obj, val);
     }
   };
-  template <>  struct traits_from< double > {
+  template <>  struct traits_from<double > {
     typedef double value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_double  (val);
@@ -5279,9 +5238,10 @@ namespace swig {
 #endif
       size_type size = seq.size();
       if (size <= (size_type)INT_MAX) {
-	PyObject *obj = PyTuple_New((Py_ssize_t)size);
-	Py_ssize_t i = 0;
-	for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) {
+	PyObject *obj = PyTuple_New((int)size);
+	int i = 0;
+	for (const_iterator it = seq.begin();
+	     it != seq.end(); ++it, ++i) {
 	  PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
 	}
 	return obj;
@@ -5312,7 +5272,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< double, std::allocator< double > > > {
+	template <>  struct traits<std::vector<double, std::allocator< double > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "double" "," "std::allocator< double >" " >";
@@ -5347,20 +5307,24 @@ SWIG_From_size_t  (size_t value)
   return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
 }
 
+SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<double,std::allocator< double > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
-    }
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v=std::vector< double,std::allocator< double > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5369,8 +5333,8 @@ SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< double,std::allocator< double > >::difference_type id = i;
-      std::vector< double,std::allocator< double > >::difference_type jd = j;
+      std::vector<double,std::allocator< double > >::difference_type id = i;
+      std::vector<double,std::allocator< double > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
@@ -5380,8 +5344,8 @@ SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< double,std::allocator< double > >::difference_type id = i;
-      std::vector< double,std::allocator< double > >::difference_type jd = j;
+      std::vector<double,std::allocator< double > >::difference_type id = i;
+      std::vector<double,std::allocator< double > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
@@ -5391,8 +5355,8 @@ SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< double,std::allocator< double > >::difference_type id = i;
-      std::vector< double,std::allocator< double > >::difference_type jd = j;
+      std::vector<double,std::allocator< double > >::difference_type id = i;
+      std::vector<double,std::allocator< double > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
@@ -5402,8 +5366,8 @@ SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< double,std::allocator< double > >::difference_type id = i;
-      std::vector< double,std::allocator< double > >::difference_type jd = j;
+      std::vector<double,std::allocator< double > >::difference_type id = i;
+      std::vector<double,std::allocator< double > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
@@ -5412,13 +5376,6 @@ SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____g
 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< double,std::allocator< double > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
       self->push_back(x);
     }
@@ -5428,7 +5385,7 @@ SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG
 SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }
 
       namespace swig {
-	template <>  struct traits<std::vector< std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
+	template <>  struct traits<std::vector<std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "std::vector< double,std::allocator< double > >" "," "std::allocator< std::vector< double,std::allocator< double > > >" " >";
@@ -5448,20 +5405,24 @@ SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____bool__(std::vector<
 SWIGINTERN std::vector< std::vector< double > >::size_type std_vector_Sl_std_vector_Sl_double_Sg__Sg____len__(std::vector< std::vector< double > > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< std::vector< double > >::value_type std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 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____getslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >());
-    }
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____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){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(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=std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 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____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5470,8 +5431,8 @@ SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allo
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
@@ -5481,8 +5442,8 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(s
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
@@ -5492,8 +5453,8 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(s
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
@@ -5503,8 +5464,8 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(s
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< std::vector< double > >::value_type const &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){
@@ -5513,13 +5474,6 @@ SWIGINTERN std::vector< std::vector< double > >::value_type const &std_vector_Sl
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< std::vector< double > >::value_type std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__append(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::value_type const &x){
       self->push_back(x);
     }
@@ -5555,17 +5509,17 @@ SWIG_AsVal_int (PyObject * obj, int *val)
 
 
 namespace swig {
-  template <> struct traits< int > {
+  template <> struct traits<int > {
     typedef value_category category;
     static const char* type_name() { return"int"; }
-  };
-  template <>  struct traits_asval< int > {
+  };  
+  template <>  struct traits_asval<int > {   
     typedef int value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_int (obj, val);
     }
   };
-  template <>  struct traits_from< int > {
+  template <>  struct traits_from<int > {
     typedef int value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_int  (val);
@@ -5575,7 +5529,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< int, std::allocator< int > > > {
+	template <>  struct traits<std::vector<int, std::allocator< int > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "int" "," "std::allocator< int >" " >";
@@ -5595,20 +5549,24 @@ SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
 SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<int,std::allocator< int > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
-    }
-SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v=std::vector< int,std::allocator< int > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5617,8 +5575,8 @@ SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____get
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< int,std::allocator< int > >::difference_type id = i;
-      std::vector< int,std::allocator< int > >::difference_type jd = j;
+      std::vector<int,std::allocator< int > >::difference_type id = i;
+      std::vector<int,std::allocator< int > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
@@ -5628,8 +5586,8 @@ SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *se
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< int,std::allocator< int > >::difference_type id = i;
-      std::vector< int,std::allocator< int > >::difference_type jd = j;
+      std::vector<int,std::allocator< int > >::difference_type id = i;
+      std::vector<int,std::allocator< int > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
@@ -5639,8 +5597,8 @@ SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *se
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< int,std::allocator< int > >::difference_type id = i;
-      std::vector< int,std::allocator< int > >::difference_type jd = j;
+      std::vector<int,std::allocator< int > >::difference_type id = i;
+      std::vector<int,std::allocator< int > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
@@ -5650,8 +5608,8 @@ SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *se
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< int,std::allocator< int > >::difference_type id = i;
-      std::vector< int,std::allocator< int > >::difference_type jd = j;
+      std::vector<int,std::allocator< int > >::difference_type id = i;
+      std::vector<int,std::allocator< int > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem____SWIG_1(std::vector< int > const *self,std::vector< int >::difference_type i){
@@ -5660,13 +5618,6 @@ SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem
 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_2(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< int,std::allocator< int > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
       self->push_back(x);
     }
@@ -5676,17 +5627,17 @@ SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__insert__SWIG_0(std
 SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::size_type n,std::vector< int >::value_type const &x){ self->insert(pos, n, x); }
 
 namespace swig {
-  template <> struct traits< unsigned long > {
+  template <> struct traits<unsigned long > {
     typedef value_category category;
     static const char* type_name() { return"unsigned long"; }
-  };
-  template <>  struct traits_asval< unsigned long > {
+  };  
+  template <>  struct traits_asval<unsigned long > {   
     typedef unsigned long value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_unsigned_SS_long (obj, val);
     }
   };
-  template <>  struct traits_from< unsigned long > {
+  template <>  struct traits_from<unsigned long > {
     typedef unsigned long value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_unsigned_SS_long  (val);
@@ -5696,7 +5647,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< unsigned long, std::allocator< unsigned long > > > {
+	template <>  struct traits<std::vector<unsigned long, std::allocator< unsigned long > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "unsigned long" "," "std::allocator< unsigned long >" " >";
@@ -5716,20 +5667,24 @@ SWIGINTERN bool std_vector_Sl_unsigned_SS_long_Sg____bool__(std::vector< unsigne
 SWIGINTERN std::vector< unsigned long >::size_type std_vector_Sl_unsigned_SS_long_Sg____len__(std::vector< unsigned long > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< unsigned long >::value_type std_vector_Sl_unsigned_SS_long_Sg__pop(std::vector< unsigned long > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<unsigned long,std::allocator< unsigned long > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getslice__(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< unsigned long,std::allocator< unsigned long > >());
-    }
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_1(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j,std::vector< unsigned long,std::allocator< unsigned long > > const &v=std::vector< unsigned long,std::allocator< unsigned long > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delslice__(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5738,8 +5693,8 @@ SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vec
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type id = i;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
@@ -5749,8 +5704,8 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vect
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type id = i;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
@@ -5760,8 +5715,8 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vect
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type id = i;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
@@ -5771,8 +5726,8 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vect
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type id = i;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< unsigned long >::value_type const &std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_1(std::vector< unsigned long > const *self,std::vector< unsigned long >::difference_type i){
@@ -5781,13 +5736,6 @@ SWIGINTERN std::vector< unsigned long >::value_type const &std_vector_Sl_unsigne
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_2(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< unsigned long >::value_type std_vector_Sl_unsigned_SS_long_Sg__pop(std::vector< unsigned long > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< unsigned long,std::allocator< unsigned long > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg__append(std::vector< unsigned long > *self,std::vector< unsigned long >::value_type const &x){
       self->push_back(x);
     }
@@ -5815,7 +5763,7 @@ SWIG_AsVal_std_complex_Sl_double_Sg_  (PyObject *o, std::complex<double>* val)
 
 
 SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_  (/*@SWIG:/usr/share/swig3.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+SWIG_From_std_complex_Sl_double_Sg_  (/*@SWIG:/usr/share/swig/3.0.7/typemaps/swigmacros.swg,104,%ifcplusplus@*/
 
 const std::complex<double>&
 
@@ -5828,17 +5776,17 @@ const std::complex<double>&
 
 
 namespace swig {
-  template <> struct traits< std::complex<double> > {
+  template <> struct traits<std::complex<double> > {
     typedef value_category category;
     static const char* type_name() { return"std::complex<double>"; }
-  };
-  template <>  struct traits_asval< std::complex<double> > {
+  };  
+  template <>  struct traits_asval<std::complex<double> > {   
     typedef std::complex<double> value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
     }
   };
-  template <>  struct traits_from< std::complex<double> > {
+  template <>  struct traits_from<std::complex<double> > {
     typedef std::complex<double> value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_std_complex_Sl_double_Sg_  (val);
@@ -5848,7 +5796,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< std::complex< double >, std::allocator< std::complex< double > > > > {
+	template <>  struct traits<std::vector<std::complex< double >, std::allocator< std::complex< double > > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "std::complex< double >" "," "std::allocator< std::complex< double > >" " >";
@@ -5868,20 +5816,24 @@ SWIGINTERN bool std_vector_Sl_std_complex_Sl_double_Sg__Sg____bool__(std::vector
 SWIGINTERN std::vector< std::complex< double > >::size_type std_vector_Sl_std_complex_Sl_double_Sg__Sg____len__(std::vector< std::complex< double > > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< std::complex< double > >::value_type std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(std::vector< std::complex< double > > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getslice__(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< std::complex< double >,std::allocator< std::complex< double > > >());
-    }
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v=std::vector< std::complex< double >,std::allocator< std::complex< double > > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delslice__(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5890,8 +5842,8 @@ SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< dou
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
@@ -5901,8 +5853,8 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
@@ -5912,8 +5864,8 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
@@ -5923,8 +5875,8 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< std::complex< double > >::value_type const &std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::complex< double > > const *self,std::vector< std::complex< double > >::difference_type i){
@@ -5933,13 +5885,6 @@ SWIGINTERN std::vector< std::complex< double > >::value_type const &std_vector_S
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< std::complex< double > >::value_type std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(std::vector< std::complex< double > > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg__append(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::value_type const &x){
       self->push_back(x);
     }
@@ -6001,17 +5946,18 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
 #else
 	if (*alloc == SWIG_NEWOBJ) 
 #endif
-	{
-	  *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
-	  *alloc = SWIG_NEWOBJ;
-	} else {
+	  {
+	    *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
+	    *alloc = SWIG_NEWOBJ;
+	  }
+	else {
 	  *cptr = cstr;
 	  *alloc = SWIG_OLDOBJ;
 	}
       } else {
-	#if PY_VERSION_HEX>=0x03000000
-	assert(0); /* Should never reach here in Python 3 */
-	#endif
+        #if PY_VERSION_HEX>=0x03000000
+        assert(0); /* Should never reach here in Python 3 */
+        #endif
 	*cptr = SWIG_Python_str_AsChar(obj);
       }
     }
@@ -6021,30 +5967,6 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
 #endif
     return SWIG_OK;
   } else {
-#if defined(SWIG_PYTHON_2_UNICODE)
-#if PY_VERSION_HEX<0x03000000
-    if (PyUnicode_Check(obj)) {
-      char *cstr; Py_ssize_t len;
-      if (!alloc && cptr) {
-        return SWIG_RuntimeError;
-      }
-      obj = PyUnicode_AsUTF8String(obj);
-      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
-        if (cptr) {
-          if (alloc) *alloc = SWIG_NEWOBJ;
-          *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
-        }
-        if (psize) *psize = len + 1;
-
-        Py_XDECREF(obj);
-        return SWIG_OK;
-      } else {
-        Py_XDECREF(obj);
-      }
-    }
-#endif
-#endif
-
     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
     if (pchar_descriptor) {
       void* vptr = 0;
@@ -6120,12 +6042,12 @@ SWIG_FromCharPtrAndSize(const char* carray, size_t size)
     } else {
 #if PY_VERSION_HEX >= 0x03000000
 #if PY_VERSION_HEX >= 0x03010000
-      return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
+      return PyUnicode_DecodeUTF8(carray, static_cast< int >(size), "surrogateescape");
 #else
-      return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
+      return PyUnicode_FromStringAndSize(carray, static_cast< int >(size));
 #endif
 #else
-      return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
+      return PyString_FromStringAndSize(carray, static_cast< int >(size));
 #endif
     }
   } else {
@@ -6142,17 +6064,17 @@ SWIG_From_std_string  (const std::string& s)
 
 
 namespace swig {
-  template <> struct traits< std::string > {
+  template <> struct traits<std::string > {
     typedef value_category category;
     static const char* type_name() { return"std::string"; }
-  };
-  template <>  struct traits_asval< std::string > {
+  };  
+  template <>  struct traits_asval<std::string > {   
     typedef std::string value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_std_string (obj, val);
     }
   };
-  template <>  struct traits_from< std::string > {
+  template <>  struct traits_from<std::string > {
     typedef std::string value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_std_string  (val);
@@ -6162,7 +6084,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< std::string, std::allocator< std::string > > > {
+	template <>  struct traits<std::vector<std::string, std::allocator< std::string > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "std::string" "," "std::allocator< std::string >" " >";
@@ -6182,20 +6104,24 @@ SWIGINTERN bool std_vector_Sl_std_string_Sg____bool__(std::vector< std::string >
 SWIGINTERN std::vector< std::string >::size_type std_vector_Sl_std_string_Sg____len__(std::vector< std::string > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<std::string,std::allocator< std::string > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< std::string,std::allocator< std::string > >());
-    }
-SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_1(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j,std::vector< std::string,std::allocator< std::string > > const &v){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j,std::vector< std::string,std::allocator< std::string > > const &v=std::vector< std::string,std::allocator< std::string > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -6204,8 +6130,8 @@ SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
-      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
+      std::vector<std::string,std::allocator< std::string > >::difference_type id = i;
+      std::vector<std::string,std::allocator< std::string > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
@@ -6215,8 +6141,8 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< st
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
-      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
+      std::vector<std::string,std::allocator< std::string > >::difference_type id = i;
+      std::vector<std::string,std::allocator< std::string > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
@@ -6226,8 +6152,8 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< st
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
-      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
+      std::vector<std::string,std::allocator< std::string > >::difference_type id = i;
+      std::vector<std::string,std::allocator< std::string > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
@@ -6237,8 +6163,8 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< st
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
-      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
+      std::vector<std::string,std::allocator< std::string > >::difference_type id = i;
+      std::vector<std::string,std::allocator< std::string > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_string_Sg____getitem____SWIG_1(std::vector< std::string > const *self,std::vector< std::string >::difference_type i){
@@ -6247,13 +6173,6 @@ SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_strin
 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_2(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< std::string,std::allocator< std::string > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_std_string_Sg__append(std::vector< std::string > *self,std::vector< std::string >::value_type const &x){
       self->push_back(x);
     }
@@ -6445,7 +6364,7 @@ SWIGINTERN Geometry::BasicVector3D< double > Geometry_BasicVector3D_Sl_double_Sg
         }
 
   namespace swig {
-    template <>  struct traits< Geometry::BasicVector3D< double > > {
+    template <>  struct traits<Geometry::BasicVector3D< double > > {
       typedef pointer_category category;
       static const char* type_name() { return"Geometry::BasicVector3D< double >"; }
     };
@@ -6453,7 +6372,7 @@ SWIGINTERN Geometry::BasicVector3D< double > Geometry_BasicVector3D_Sl_double_Sg
 
 
       namespace swig {
-	template <>  struct traits<std::vector< Geometry::BasicVector3D< double >, std::allocator< Geometry::BasicVector3D< double > > > > {
+	template <>  struct traits<std::vector<Geometry::BasicVector3D< double >, std::allocator< Geometry::BasicVector3D< double > > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "Geometry::BasicVector3D< double >" "," "std::allocator< Geometry::BasicVector3D< double > >" " >";
@@ -6473,20 +6392,24 @@ SWIGINTERN bool std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____bool__(
 SWIGINTERN std::vector< Geometry::BasicVector3D< double > >::size_type std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____len__(std::vector< Geometry::BasicVector3D< double > > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< Geometry::BasicVector3D< double > >::value_type std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg__pop(std::vector< Geometry::BasicVector3D< double > > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____getslice__(std::vector< Geometry::BasicVector3D< double > > *self,std::vector< Geometry::BasicVector3D< double > >::difference_type i,std::vector< Geometry::BasicVector3D< double > >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< Geometry::BasicVector3D< double > > *self,std::vector< Geometry::BasicVector3D< double > >::difference_type i,std::vector< Geometry::BasicVector3D< double > >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >());
-    }
-SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< Geometry::BasicVector3D< double > > *self,std::vector< Geometry::BasicVector3D< double > >::difference_type i,std::vector< Geometry::BasicVector3D< double > >::difference_type j,std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > const &v){
+SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< Geometry::BasicVector3D< double > > *self,std::vector< Geometry::BasicVector3D< double > >::difference_type i,std::vector< Geometry::BasicVector3D< double > >::difference_type j,std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > const &v=std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____delslice__(std::vector< Geometry::BasicVector3D< double > > *self,std::vector< Geometry::BasicVector3D< double > >::difference_type i,std::vector< Geometry::BasicVector3D< double > >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< Geometry::BasicVector3D< double > > *self,std::vector< Geometry::BasicVector3D< double > >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< Geometry::BasicVector3D< double > > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -6495,8 +6418,8 @@ SWIGINTERN std::vector< Geometry::BasicVector3D< double >,std::allocator< Geomet
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type id = i;
-      std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type jd = j;
+      std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type id = i;
+      std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< Geometry::BasicVector3D< double > > *self,PySliceObject *slice,std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > const &v){
@@ -6506,8 +6429,8 @@ SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____setitem
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type id = i;
-      std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type jd = j;
+      std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type id = i;
+      std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< Geometry::BasicVector3D< double > > *self,PySliceObject *slice){
@@ -6517,8 +6440,8 @@ SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____setitem
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type id = i;
-      std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type jd = j;
+      std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type id = i;
+      std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< Geometry::BasicVector3D< double > > *self,PySliceObject *slice){
@@ -6528,8 +6451,8 @@ SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____delitem
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type id = i;
-      std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type jd = j;
+      std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type id = i;
+      std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< Geometry::BasicVector3D< double > >::value_type const &std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< Geometry::BasicVector3D< double > > const *self,std::vector< Geometry::BasicVector3D< double > >::difference_type i){
@@ -6538,13 +6461,6 @@ SWIGINTERN std::vector< Geometry::BasicVector3D< double > >::value_type const &s
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< Geometry::BasicVector3D< double > > *self,std::vector< Geometry::BasicVector3D< double > >::difference_type i,std::vector< Geometry::BasicVector3D< double > >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< Geometry::BasicVector3D< double > >::value_type std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg__pop(std::vector< Geometry::BasicVector3D< double > > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg__append(std::vector< Geometry::BasicVector3D< double > > *self,std::vector< Geometry::BasicVector3D< double > >::value_type const &x){
       self->push_back(x);
     }
@@ -6554,7 +6470,7 @@ SWIGINTERN std::vector< Geometry::BasicVector3D< double > >::iterator std_vector
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg__insert__SWIG_1(std::vector< Geometry::BasicVector3D< double > > *self,std::vector< Geometry::BasicVector3D< double > >::iterator pos,std::vector< Geometry::BasicVector3D< double > >::size_type n,std::vector< Geometry::BasicVector3D< double > >::value_type const &x){ self->insert(pos, n, x); }
 
   namespace swig {
-    template <>  struct traits< Geometry::BasicVector3D< std::complex< double > > > {
+    template <>  struct traits<Geometry::BasicVector3D< std::complex< double > > > {
       typedef pointer_category category;
       static const char* type_name() { return"Geometry::BasicVector3D< std::complex< double > >"; }
     };
@@ -6562,7 +6478,7 @@ SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg__insert__S
 
 
       namespace swig {
-	template <>  struct traits<std::vector< Geometry::BasicVector3D< std::complex< double > >, std::allocator< Geometry::BasicVector3D< std::complex< double > > > > > {
+	template <>  struct traits<std::vector<Geometry::BasicVector3D< std::complex< double > >, std::allocator< Geometry::BasicVector3D< std::complex< double > > > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "Geometry::BasicVector3D< std::complex< double > >" "," "std::allocator< Geometry::BasicVector3D< std::complex< double > > >" " >";
@@ -6582,20 +6498,24 @@ SWIGINTERN bool std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg
 SWIGINTERN std::vector< Geometry::BasicVector3D< std::complex< double > > >::size_type std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____len__(std::vector< Geometry::BasicVector3D< std::complex< double > > > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< Geometry::BasicVector3D< std::complex< double > > >::value_type std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg__pop(std::vector< Geometry::BasicVector3D< std::complex< double > > > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____getslice__(std::vector< Geometry::BasicVector3D< std::complex< double > > > *self,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____setslice____SWIG_0(std::vector< Geometry::BasicVector3D< std::complex< double > > > *self,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >());
-    }
-SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____setslice____SWIG_1(std::vector< Geometry::BasicVector3D< std::complex< double > > > *self,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j,std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > const &v){
+SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____setslice____SWIG_0(std::vector< Geometry::BasicVector3D< std::complex< double > > > *self,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j,std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > const &v=std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____delslice__(std::vector< Geometry::BasicVector3D< std::complex< double > > > *self,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____delitem____SWIG_0(std::vector< Geometry::BasicVector3D< std::complex< double > > > *self,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____getitem____SWIG_0(std::vector< Geometry::BasicVector3D< std::complex< double > > > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -6604,8 +6524,8 @@ SWIGINTERN std::vector< Geometry::BasicVector3D< std::complex< double > >,std::a
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type id = i;
-      std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type jd = j;
+      std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type id = i;
+      std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____setitem____SWIG_0(std::vector< Geometry::BasicVector3D< std::complex< double > > > *self,PySliceObject *slice,std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > const &v){
@@ -6615,8 +6535,8 @@ SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type id = i;
-      std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type jd = j;
+      std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type id = i;
+      std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____setitem____SWIG_1(std::vector< Geometry::BasicVector3D< std::complex< double > > > *self,PySliceObject *slice){
@@ -6626,8 +6546,8 @@ SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type id = i;
-      std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type jd = j;
+      std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type id = i;
+      std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____delitem____SWIG_1(std::vector< Geometry::BasicVector3D< std::complex< double > > > *self,PySliceObject *slice){
@@ -6637,8 +6557,8 @@ SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type id = i;
-      std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type jd = j;
+      std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type id = i;
+      std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< Geometry::BasicVector3D< std::complex< double > > >::value_type const &std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____getitem____SWIG_1(std::vector< Geometry::BasicVector3D< std::complex< double > > > const *self,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i){
@@ -6647,13 +6567,6 @@ SWIGINTERN std::vector< Geometry::BasicVector3D< std::complex< double > > >::val
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____setitem____SWIG_2(std::vector< Geometry::BasicVector3D< std::complex< double > > > *self,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i,std::vector< Geometry::BasicVector3D< std::complex< double > > >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< Geometry::BasicVector3D< std::complex< double > > >::value_type std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg__pop(std::vector< Geometry::BasicVector3D< std::complex< double > > > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg__append(std::vector< Geometry::BasicVector3D< std::complex< double > > > *self,std::vector< Geometry::BasicVector3D< std::complex< double > > >::value_type const &x){
       self->push_back(x);
     }
@@ -6685,7 +6598,7 @@ SWIGINTERN double VariableBinAxis___getitem__(VariableBinAxis *self,unsigned int
     }
 
   namespace swig {
-    template <>  struct traits< ISample > {
+    template <>  struct traits<ISample > {
       typedef pointer_category category;
       static const char* type_name() { return"ISample"; }
     };
@@ -6693,7 +6606,7 @@ SWIGINTERN double VariableBinAxis___getitem__(VariableBinAxis *self,unsigned int
 
 
       namespace swig {
-	template <>  struct traits<std::vector< ISample*, std::allocator< ISample * > > > {
+	template <>  struct traits<std::vector<ISample*, std::allocator< ISample * > > > {
 	  typedef value_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "ISample" " *," "std::allocator< ISample * >" " >";
@@ -6713,20 +6626,24 @@ SWIGINTERN bool std_vector_Sl_ISample_Sm__Sg____bool__(std::vector< ISample * >
 SWIGINTERN std::vector< ISample * >::size_type std_vector_Sl_ISample_Sm__Sg____len__(std::vector< ISample * > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< ISample * >::value_type std_vector_Sl_ISample_Sm__Sg__pop(std::vector< ISample * > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<ISample*,std::allocator< ISample * > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< ISample *,std::allocator< ISample * > > *std_vector_Sl_ISample_Sm__Sg____getslice__(std::vector< ISample * > *self,std::vector< ISample * >::difference_type i,std::vector< ISample * >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_ISample_Sm__Sg____setslice____SWIG_0(std::vector< ISample * > *self,std::vector< ISample * >::difference_type i,std::vector< ISample * >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< ISample*,std::allocator< ISample * > >());
-    }
-SWIGINTERN void std_vector_Sl_ISample_Sm__Sg____setslice____SWIG_1(std::vector< ISample * > *self,std::vector< ISample * >::difference_type i,std::vector< ISample * >::difference_type j,std::vector< ISample *,std::allocator< ISample * > > const &v){
+SWIGINTERN void std_vector_Sl_ISample_Sm__Sg____setslice____SWIG_0(std::vector< ISample * > *self,std::vector< ISample * >::difference_type i,std::vector< ISample * >::difference_type j,std::vector< ISample *,std::allocator< ISample * > > const &v=std::vector< ISample *,std::allocator< ISample * > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_ISample_Sm__Sg____delslice__(std::vector< ISample * > *self,std::vector< ISample * >::difference_type i,std::vector< ISample * >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_ISample_Sm__Sg____delitem____SWIG_0(std::vector< ISample * > *self,std::vector< ISample * >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< ISample *,std::allocator< ISample * > > *std_vector_Sl_ISample_Sm__Sg____getitem____SWIG_0(std::vector< ISample * > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -6735,8 +6652,8 @@ SWIGINTERN std::vector< ISample *,std::allocator< ISample * > > *std_vector_Sl_I
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< ISample*,std::allocator< ISample * > >::difference_type id = i;
-      std::vector< ISample*,std::allocator< ISample * > >::difference_type jd = j;
+      std::vector<ISample*,std::allocator< ISample * > >::difference_type id = i;
+      std::vector<ISample*,std::allocator< ISample * > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_ISample_Sm__Sg____setitem____SWIG_0(std::vector< ISample * > *self,PySliceObject *slice,std::vector< ISample *,std::allocator< ISample * > > const &v){
@@ -6746,8 +6663,8 @@ SWIGINTERN void std_vector_Sl_ISample_Sm__Sg____setitem____SWIG_0(std::vector< I
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< ISample*,std::allocator< ISample * > >::difference_type id = i;
-      std::vector< ISample*,std::allocator< ISample * > >::difference_type jd = j;
+      std::vector<ISample*,std::allocator< ISample * > >::difference_type id = i;
+      std::vector<ISample*,std::allocator< ISample * > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_ISample_Sm__Sg____setitem____SWIG_1(std::vector< ISample * > *self,PySliceObject *slice){
@@ -6757,8 +6674,8 @@ SWIGINTERN void std_vector_Sl_ISample_Sm__Sg____setitem____SWIG_1(std::vector< I
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< ISample*,std::allocator< ISample * > >::difference_type id = i;
-      std::vector< ISample*,std::allocator< ISample * > >::difference_type jd = j;
+      std::vector<ISample*,std::allocator< ISample * > >::difference_type id = i;
+      std::vector<ISample*,std::allocator< ISample * > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_ISample_Sm__Sg____delitem____SWIG_1(std::vector< ISample * > *self,PySliceObject *slice){
@@ -6768,8 +6685,8 @@ SWIGINTERN void std_vector_Sl_ISample_Sm__Sg____delitem____SWIG_1(std::vector< I
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< ISample*,std::allocator< ISample * > >::difference_type id = i;
-      std::vector< ISample*,std::allocator< ISample * > >::difference_type jd = j;
+      std::vector<ISample*,std::allocator< ISample * > >::difference_type id = i;
+      std::vector<ISample*,std::allocator< ISample * > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< ISample * >::value_type std_vector_Sl_ISample_Sm__Sg____getitem____SWIG_1(std::vector< ISample * > *self,std::vector< ISample * >::difference_type i){
@@ -6778,13 +6695,6 @@ SWIGINTERN std::vector< ISample * >::value_type std_vector_Sl_ISample_Sm__Sg____
 SWIGINTERN void std_vector_Sl_ISample_Sm__Sg____setitem____SWIG_2(std::vector< ISample * > *self,std::vector< ISample * >::difference_type i,std::vector< ISample * >::value_type x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< ISample * >::value_type std_vector_Sl_ISample_Sm__Sg__pop(std::vector< ISample * > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< ISample*,std::allocator< ISample * > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_ISample_Sm__Sg__append(std::vector< ISample * > *self,std::vector< ISample * >::value_type x){
       self->push_back(x);
     }
@@ -6794,7 +6704,7 @@ SWIGINTERN std::vector< ISample * >::iterator std_vector_Sl_ISample_Sm__Sg__inse
 SWIGINTERN void std_vector_Sl_ISample_Sm__Sg__insert__SWIG_1(std::vector< ISample * > *self,std::vector< ISample * >::iterator pos,std::vector< ISample * >::size_type n,std::vector< ISample * >::value_type x){ self->insert(pos, n, x); }
 
       namespace swig {
-	template <>  struct traits<std::vector< ISample const*, std::allocator< ISample const * > > > {
+	template <>  struct traits<std::vector<ISample const*, std::allocator< ISample const * > > > {
 	  typedef value_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "ISample" " const*," "std::allocator< ISample const * >" " >";
@@ -6814,20 +6724,24 @@ SWIGINTERN bool std_vector_Sl_ISample_SS_const_Sm__Sg____bool__(std::vector< ISa
 SWIGINTERN std::vector< ISample const * >::size_type std_vector_Sl_ISample_SS_const_Sm__Sg____len__(std::vector< ISample const * > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< ISample const * >::value_type std_vector_Sl_ISample_SS_const_Sm__Sg__pop(std::vector< ISample const * > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<ISample const*,std::allocator< ISample const * > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< ISample const *,std::allocator< ISample const * > > *std_vector_Sl_ISample_SS_const_Sm__Sg____getslice__(std::vector< ISample const * > *self,std::vector< ISample const * >::difference_type i,std::vector< ISample const * >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_ISample_SS_const_Sm__Sg____setslice____SWIG_0(std::vector< ISample const * > *self,std::vector< ISample const * >::difference_type i,std::vector< ISample const * >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< ISample const*,std::allocator< ISample const * > >());
-    }
-SWIGINTERN void std_vector_Sl_ISample_SS_const_Sm__Sg____setslice____SWIG_1(std::vector< ISample const * > *self,std::vector< ISample const * >::difference_type i,std::vector< ISample const * >::difference_type j,std::vector< ISample const *,std::allocator< ISample const * > > const &v){
+SWIGINTERN void std_vector_Sl_ISample_SS_const_Sm__Sg____setslice____SWIG_0(std::vector< ISample const * > *self,std::vector< ISample const * >::difference_type i,std::vector< ISample const * >::difference_type j,std::vector< ISample const *,std::allocator< ISample const * > > const &v=std::vector< ISample const *,std::allocator< ISample const * > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_ISample_SS_const_Sm__Sg____delslice__(std::vector< ISample const * > *self,std::vector< ISample const * >::difference_type i,std::vector< ISample const * >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_ISample_SS_const_Sm__Sg____delitem____SWIG_0(std::vector< ISample const * > *self,std::vector< ISample const * >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< ISample const *,std::allocator< ISample const * > > *std_vector_Sl_ISample_SS_const_Sm__Sg____getitem____SWIG_0(std::vector< ISample const * > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -6836,8 +6750,8 @@ SWIGINTERN std::vector< ISample const *,std::allocator< ISample const * > > *std
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< ISample const*,std::allocator< ISample const * > >::difference_type id = i;
-      std::vector< ISample const*,std::allocator< ISample const * > >::difference_type jd = j;
+      std::vector<ISample const*,std::allocator< ISample const * > >::difference_type id = i;
+      std::vector<ISample const*,std::allocator< ISample const * > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_ISample_SS_const_Sm__Sg____setitem____SWIG_0(std::vector< ISample const * > *self,PySliceObject *slice,std::vector< ISample const *,std::allocator< ISample const * > > const &v){
@@ -6847,8 +6761,8 @@ SWIGINTERN void std_vector_Sl_ISample_SS_const_Sm__Sg____setitem____SWIG_0(std::
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< ISample const*,std::allocator< ISample const * > >::difference_type id = i;
-      std::vector< ISample const*,std::allocator< ISample const * > >::difference_type jd = j;
+      std::vector<ISample const*,std::allocator< ISample const * > >::difference_type id = i;
+      std::vector<ISample const*,std::allocator< ISample const * > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_ISample_SS_const_Sm__Sg____setitem____SWIG_1(std::vector< ISample const * > *self,PySliceObject *slice){
@@ -6858,8 +6772,8 @@ SWIGINTERN void std_vector_Sl_ISample_SS_const_Sm__Sg____setitem____SWIG_1(std::
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< ISample const*,std::allocator< ISample const * > >::difference_type id = i;
-      std::vector< ISample const*,std::allocator< ISample const * > >::difference_type jd = j;
+      std::vector<ISample const*,std::allocator< ISample const * > >::difference_type id = i;
+      std::vector<ISample const*,std::allocator< ISample const * > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_ISample_SS_const_Sm__Sg____delitem____SWIG_1(std::vector< ISample const * > *self,PySliceObject *slice){
@@ -6869,8 +6783,8 @@ SWIGINTERN void std_vector_Sl_ISample_SS_const_Sm__Sg____delitem____SWIG_1(std::
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< ISample const*,std::allocator< ISample const * > >::difference_type id = i;
-      std::vector< ISample const*,std::allocator< ISample const * > >::difference_type jd = j;
+      std::vector<ISample const*,std::allocator< ISample const * > >::difference_type id = i;
+      std::vector<ISample const*,std::allocator< ISample const * > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< ISample const * >::value_type std_vector_Sl_ISample_SS_const_Sm__Sg____getitem____SWIG_1(std::vector< ISample const * > *self,std::vector< ISample const * >::difference_type i){
@@ -6879,13 +6793,6 @@ SWIGINTERN std::vector< ISample const * >::value_type std_vector_Sl_ISample_SS_c
 SWIGINTERN void std_vector_Sl_ISample_SS_const_Sm__Sg____setitem____SWIG_2(std::vector< ISample const * > *self,std::vector< ISample const * >::difference_type i,std::vector< ISample const * >::value_type x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< ISample const * >::value_type std_vector_Sl_ISample_SS_const_Sm__Sg__pop(std::vector< ISample const * > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< ISample const*,std::allocator< ISample const * > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_ISample_SS_const_Sm__Sg__append(std::vector< ISample const * > *self,std::vector< ISample const * >::value_type x){
       self->push_back(x);
     }
@@ -6901,7 +6808,7 @@ SWIGINTERN double FixedBinAxis___getitem__(FixedBinAxis *self,unsigned int i){
     }
 
   namespace swig {
-    template <>  struct traits< IFormFactor > {
+    template <>  struct traits<IFormFactor > {
       typedef pointer_category category;
       static const char* type_name() { return"IFormFactor"; }
     };
@@ -6909,7 +6816,7 @@ SWIGINTERN double FixedBinAxis___getitem__(FixedBinAxis *self,unsigned int i){
 
 
       namespace swig {
-	template <>  struct traits<std::vector< IFormFactor*, std::allocator< IFormFactor * > > > {
+	template <>  struct traits<std::vector<IFormFactor*, std::allocator< IFormFactor * > > > {
 	  typedef value_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "IFormFactor" " *," "std::allocator< IFormFactor * >" " >";
@@ -6929,20 +6836,24 @@ SWIGINTERN bool std_vector_Sl_IFormFactor_Sm__Sg____bool__(std::vector< IFormFac
 SWIGINTERN std::vector< IFormFactor * >::size_type std_vector_Sl_IFormFactor_Sm__Sg____len__(std::vector< IFormFactor * > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< IFormFactor * >::value_type std_vector_Sl_IFormFactor_Sm__Sg__pop(std::vector< IFormFactor * > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<IFormFactor*,std::allocator< IFormFactor * > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< IFormFactor *,std::allocator< IFormFactor * > > *std_vector_Sl_IFormFactor_Sm__Sg____getslice__(std::vector< IFormFactor * > *self,std::vector< IFormFactor * >::difference_type i,std::vector< IFormFactor * >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_IFormFactor_Sm__Sg____setslice____SWIG_0(std::vector< IFormFactor * > *self,std::vector< IFormFactor * >::difference_type i,std::vector< IFormFactor * >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< IFormFactor*,std::allocator< IFormFactor * > >());
-    }
-SWIGINTERN void std_vector_Sl_IFormFactor_Sm__Sg____setslice____SWIG_1(std::vector< IFormFactor * > *self,std::vector< IFormFactor * >::difference_type i,std::vector< IFormFactor * >::difference_type j,std::vector< IFormFactor *,std::allocator< IFormFactor * > > const &v){
+SWIGINTERN void std_vector_Sl_IFormFactor_Sm__Sg____setslice____SWIG_0(std::vector< IFormFactor * > *self,std::vector< IFormFactor * >::difference_type i,std::vector< IFormFactor * >::difference_type j,std::vector< IFormFactor *,std::allocator< IFormFactor * > > const &v=std::vector< IFormFactor *,std::allocator< IFormFactor * > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_IFormFactor_Sm__Sg____delslice__(std::vector< IFormFactor * > *self,std::vector< IFormFactor * >::difference_type i,std::vector< IFormFactor * >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_IFormFactor_Sm__Sg____delitem____SWIG_0(std::vector< IFormFactor * > *self,std::vector< IFormFactor * >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< IFormFactor *,std::allocator< IFormFactor * > > *std_vector_Sl_IFormFactor_Sm__Sg____getitem____SWIG_0(std::vector< IFormFactor * > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -6951,8 +6862,8 @@ SWIGINTERN std::vector< IFormFactor *,std::allocator< IFormFactor * > > *std_vec
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< IFormFactor*,std::allocator< IFormFactor * > >::difference_type id = i;
-      std::vector< IFormFactor*,std::allocator< IFormFactor * > >::difference_type jd = j;
+      std::vector<IFormFactor*,std::allocator< IFormFactor * > >::difference_type id = i;
+      std::vector<IFormFactor*,std::allocator< IFormFactor * > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_IFormFactor_Sm__Sg____setitem____SWIG_0(std::vector< IFormFactor * > *self,PySliceObject *slice,std::vector< IFormFactor *,std::allocator< IFormFactor * > > const &v){
@@ -6962,8 +6873,8 @@ SWIGINTERN void std_vector_Sl_IFormFactor_Sm__Sg____setitem____SWIG_0(std::vecto
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< IFormFactor*,std::allocator< IFormFactor * > >::difference_type id = i;
-      std::vector< IFormFactor*,std::allocator< IFormFactor * > >::difference_type jd = j;
+      std::vector<IFormFactor*,std::allocator< IFormFactor * > >::difference_type id = i;
+      std::vector<IFormFactor*,std::allocator< IFormFactor * > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_IFormFactor_Sm__Sg____setitem____SWIG_1(std::vector< IFormFactor * > *self,PySliceObject *slice){
@@ -6973,8 +6884,8 @@ SWIGINTERN void std_vector_Sl_IFormFactor_Sm__Sg____setitem____SWIG_1(std::vecto
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< IFormFactor*,std::allocator< IFormFactor * > >::difference_type id = i;
-      std::vector< IFormFactor*,std::allocator< IFormFactor * > >::difference_type jd = j;
+      std::vector<IFormFactor*,std::allocator< IFormFactor * > >::difference_type id = i;
+      std::vector<IFormFactor*,std::allocator< IFormFactor * > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_IFormFactor_Sm__Sg____delitem____SWIG_1(std::vector< IFormFactor * > *self,PySliceObject *slice){
@@ -6984,8 +6895,8 @@ SWIGINTERN void std_vector_Sl_IFormFactor_Sm__Sg____delitem____SWIG_1(std::vecto
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< IFormFactor*,std::allocator< IFormFactor * > >::difference_type id = i;
-      std::vector< IFormFactor*,std::allocator< IFormFactor * > >::difference_type jd = j;
+      std::vector<IFormFactor*,std::allocator< IFormFactor * > >::difference_type id = i;
+      std::vector<IFormFactor*,std::allocator< IFormFactor * > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< IFormFactor * >::value_type std_vector_Sl_IFormFactor_Sm__Sg____getitem____SWIG_1(std::vector< IFormFactor * > *self,std::vector< IFormFactor * >::difference_type i){
@@ -6994,13 +6905,6 @@ SWIGINTERN std::vector< IFormFactor * >::value_type std_vector_Sl_IFormFactor_Sm
 SWIGINTERN void std_vector_Sl_IFormFactor_Sm__Sg____setitem____SWIG_2(std::vector< IFormFactor * > *self,std::vector< IFormFactor * >::difference_type i,std::vector< IFormFactor * >::value_type x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< IFormFactor * >::value_type std_vector_Sl_IFormFactor_Sm__Sg__pop(std::vector< IFormFactor * > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< IFormFactor*,std::allocator< IFormFactor * > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_IFormFactor_Sm__Sg__append(std::vector< IFormFactor * > *self,std::vector< IFormFactor * >::value_type x){
       self->push_back(x);
     }
@@ -7723,7 +7627,7 @@ std::vector< double,std::allocator< double > > SwigDirector_IAxis::getBinCenters
       Swig::DirectorMethodException::raise("Error detected when calling 'IAxis.getBinCenters'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -7753,7 +7657,7 @@ std::vector< double,std::allocator< double > > SwigDirector_IAxis::getBinBoundar
       Swig::DirectorMethodException::raise("Error detected when calling 'IAxis.getBinBoundaries'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -8180,7 +8084,7 @@ std::vector< double,std::allocator< double > > SwigDirector_VariableBinAxis::get
       Swig::DirectorMethodException::raise("Error detected when calling 'VariableBinAxis.getBinCenters'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -8210,7 +8114,7 @@ std::vector< double,std::allocator< double > > SwigDirector_VariableBinAxis::get
       Swig::DirectorMethodException::raise("Error detected when calling 'VariableBinAxis.getBinBoundaries'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -8637,7 +8541,7 @@ std::vector< double,std::allocator< double > > SwigDirector_ConstKBinAxis::getBi
       Swig::DirectorMethodException::raise("Error detected when calling 'ConstKBinAxis.getBinCenters'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -8667,7 +8571,7 @@ std::vector< double,std::allocator< double > > SwigDirector_ConstKBinAxis::getBi
       Swig::DirectorMethodException::raise("Error detected when calling 'ConstKBinAxis.getBinBoundaries'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -9087,7 +8991,7 @@ std::vector< double,std::allocator< double > > SwigDirector_CustomBinAxis::getBi
       Swig::DirectorMethodException::raise("Error detected when calling 'CustomBinAxis.getBinCenters'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -9117,7 +9021,7 @@ std::vector< double,std::allocator< double > > SwigDirector_CustomBinAxis::getBi
       Swig::DirectorMethodException::raise("Error detected when calling 'CustomBinAxis.getBinBoundaries'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -11787,7 +11691,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_IC
       Swig::DirectorMethodException::raise("Error detected when calling 'ICompositeSample.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -12179,7 +12083,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_IC
       Swig::DirectorMethodException::raise("Error detected when calling 'IClusteredParticles.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -12689,7 +12593,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Cr
       Swig::DirectorMethodException::raise("Error detected when calling 'Crystal.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -13105,7 +13009,7 @@ std::vector< double,std::allocator< double > > SwigDirector_IDistribution1D::gen
       Swig::DirectorMethodException::raise("Error detected when calling 'IDistribution1D.generateValueList'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -13141,7 +13045,7 @@ std::vector< double,std::allocator< double > > SwigDirector_IDistribution1D::gen
       Swig::DirectorMethodException::raise("Error detected when calling 'IDistribution1D.generateValues'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -13371,7 +13275,7 @@ std::vector< double,std::allocator< double > > SwigDirector_DistributionGate::ge
       Swig::DirectorMethodException::raise("Error detected when calling 'DistributionGate.generateValueList'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -13407,7 +13311,7 @@ std::vector< double,std::allocator< double > > SwigDirector_DistributionGate::ge
       Swig::DirectorMethodException::raise("Error detected when calling 'DistributionGate.generateValues'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -13637,7 +13541,7 @@ std::vector< double,std::allocator< double > > SwigDirector_DistributionLorentz:
       Swig::DirectorMethodException::raise("Error detected when calling 'DistributionLorentz.generateValueList'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -13673,7 +13577,7 @@ std::vector< double,std::allocator< double > > SwigDirector_DistributionLorentz:
       Swig::DirectorMethodException::raise("Error detected when calling 'DistributionLorentz.generateValues'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -13903,7 +13807,7 @@ std::vector< double,std::allocator< double > > SwigDirector_DistributionGaussian
       Swig::DirectorMethodException::raise("Error detected when calling 'DistributionGaussian.generateValueList'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -13939,7 +13843,7 @@ std::vector< double,std::allocator< double > > SwigDirector_DistributionGaussian
       Swig::DirectorMethodException::raise("Error detected when calling 'DistributionGaussian.generateValues'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -14169,7 +14073,7 @@ std::vector< double,std::allocator< double > > SwigDirector_DistributionLogNorma
       Swig::DirectorMethodException::raise("Error detected when calling 'DistributionLogNormal.generateValueList'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -14205,7 +14109,7 @@ std::vector< double,std::allocator< double > > SwigDirector_DistributionLogNorma
       Swig::DirectorMethodException::raise("Error detected when calling 'DistributionLogNormal.generateValues'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -14435,7 +14339,7 @@ std::vector< double,std::allocator< double > > SwigDirector_DistributionCosine::
       Swig::DirectorMethodException::raise("Error detected when calling 'DistributionCosine.generateValueList'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -14471,7 +14375,7 @@ std::vector< double,std::allocator< double > > SwigDirector_DistributionCosine::
       Swig::DirectorMethodException::raise("Error detected when calling 'DistributionCosine.generateValues'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -18532,7 +18436,7 @@ std::vector< double,std::allocator< double > > SwigDirector_FixedBinAxis::getBin
       Swig::DirectorMethodException::raise("Error detected when calling 'FixedBinAxis.getBinCenters'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -18562,7 +18466,7 @@ std::vector< double,std::allocator< double > > SwigDirector_FixedBinAxis::getBin
       Swig::DirectorMethodException::raise("Error detected when calling 'FixedBinAxis.getBinBoundaries'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -19005,7 +18909,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_IF
       Swig::DirectorMethodException::raise("Error detected when calling 'IFormFactor.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -19488,7 +19392,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_IF
       Swig::DirectorMethodException::raise("Error detected when calling 'IFormFactorBorn.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -20033,7 +19937,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_IF
       Swig::DirectorMethodException::raise("Error detected when calling 'IFormFactorDecorator.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -20516,7 +20420,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorAnisoPyramid.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -21061,7 +20965,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorBox.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -21606,7 +21510,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorCone.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -22151,7 +22055,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorCone6.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -22696,7 +22600,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorCrystal.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -23241,7 +23145,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorCuboctahedron.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -23786,7 +23690,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorCylinder.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -24338,7 +24242,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorDecoratorDebyeWaller.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -24852,7 +24756,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorEllipsoidalCylinder.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -25397,7 +25301,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorFullSphere.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -25942,7 +25846,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorFullSpheroid.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -26494,7 +26398,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorGauss.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -27039,7 +26943,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorHemiEllipsoid.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -27584,7 +27488,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorLongBoxGauss.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -28129,7 +28033,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorLongBoxLorentz.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -28681,7 +28585,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorLorentz.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -29226,7 +29130,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorPrism3.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -29771,7 +29675,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorPrism6.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -30316,7 +30220,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorPyramid.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -30861,7 +30765,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorRipple1.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -31406,7 +31310,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorRipple2.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -31951,7 +31855,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorSphereGaussianRadius.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -32496,7 +32400,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorSphereLogNormalRadius.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -33041,7 +32945,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorSphereUniformRadius.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -33586,7 +33490,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorTetrahedron.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -34131,7 +34035,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorTrivial.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -34676,7 +34580,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorTruncatedCube.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -35223,7 +35127,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorTruncatedSphere.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -35770,7 +35674,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorTruncatedSpheroid.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -36315,7 +36219,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Fo
       Swig::DirectorMethodException::raise("Error detected when calling 'FormFactorWeighted.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -38790,7 +38694,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_II
       Swig::DirectorMethodException::raise("Error detected when calling 'IInterferenceFunction.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -39225,7 +39129,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_IL
       Swig::DirectorMethodException::raise("Error detected when calling 'ILayout.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -39916,7 +39820,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_IA
       Swig::DirectorMethodException::raise("Error detected when calling 'IAbstractParticle.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -40364,7 +40268,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_IP
       Swig::DirectorMethodException::raise("Error detected when calling 'IParticle.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -41009,7 +40913,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_IR
       Swig::DirectorMethodException::raise("Error detected when calling 'IRotation.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -41449,7 +41353,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Ro
       Swig::DirectorMethodException::raise("Error detected when calling 'RotationX.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -41889,7 +41793,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Ro
       Swig::DirectorMethodException::raise("Error detected when calling 'RotationY.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -42329,7 +42233,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Ro
       Swig::DirectorMethodException::raise("Error detected when calling 'RotationZ.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -42769,7 +42673,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Ro
       Swig::DirectorMethodException::raise("Error detected when calling 'RotationEuler.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -43458,7 +43362,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_In
       Swig::DirectorMethodException::raise("Error detected when calling 'InterferenceFunction1DLattice.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -43893,7 +43797,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_In
       Swig::DirectorMethodException::raise("Error detected when calling 'InterferenceFunctionRadialParaCrystal.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -44328,7 +44232,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_In
       Swig::DirectorMethodException::raise("Error detected when calling 'InterferenceFunction2DLattice.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -44763,7 +44667,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_In
       Swig::DirectorMethodException::raise("Error detected when calling 'InterferenceFunction2DParaCrystal.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -45198,7 +45102,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_In
       Swig::DirectorMethodException::raise("Error detected when calling 'InterferenceFunctionNone.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -46759,7 +46663,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_La
       Swig::DirectorMethodException::raise("Error detected when calling 'Layer.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -47425,7 +47329,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_IR
       Swig::DirectorMethodException::raise("Error detected when calling 'IRoughness.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -47778,7 +47682,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_La
       Swig::DirectorMethodException::raise("Error detected when calling 'LayerRoughness.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -48589,7 +48493,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Me
       Swig::DirectorMethodException::raise("Error detected when calling 'MesoCrystal.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -49074,7 +48978,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Mu
       Swig::DirectorMethodException::raise("Error detected when calling 'MultiLayer.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -50022,7 +49926,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Pa
       Swig::DirectorMethodException::raise("Error detected when calling 'Particle.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -50613,7 +50517,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Pa
       Swig::DirectorMethodException::raise("Error detected when calling 'ParticleComposition.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -51105,7 +51009,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Pa
       Swig::DirectorMethodException::raise("Error detected when calling 'ParticleCoreShell.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -51590,7 +51494,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Pa
       Swig::DirectorMethodException::raise("Error detected when calling 'ParticleDistribution.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -52075,7 +51979,7 @@ std::vector< ISample const *,std::allocator< ISample const * > > SwigDirector_Pa
       Swig::DirectorMethodException::raise("Error detected when calling 'ParticleLayout.getChildren'");
     }
   }
-  std::vector< ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
+  std::vector<ISample const*,std::allocator< ISample const * > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< ISample const *,std::allocator< ISample const * > >""'");
@@ -53847,14 +53751,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -53996,14 +53900,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -54586,14 +54490,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -54740,56 +54644,35 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vdouble1d_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
-  std::vector< double >::difference_type arg2 ;
-  std::vector< double >::difference_type arg3 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  ptrdiff_t val3 ;
-  int ecode3 = 0 ;
   PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  std::vector< double,std::allocator< double > > *result = 0 ;
+  std::vector< double >::value_type result;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:vdouble1d_t___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_pop",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_pop" "', argument " "1"" of type '" "std::vector< double > *""'"); 
   }
   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vdouble1d_t___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
-  } 
-  arg2 = static_cast< std::vector< double >::difference_type >(val2);
-  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vdouble1d_t___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
-  } 
-  arg3 = static_cast< std::vector< double >::difference_type >(val3);
   try {
-    result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getslice__(arg1,arg2,arg3);
+    result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_From_double(static_cast< double >(result));
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vdouble1d_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
   std::vector< double >::difference_type arg2 ;
@@ -54803,25 +54686,26 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_0(PyObject *SWIGUNUSED
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  std::vector< double,std::allocator< double > > *result = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:vdouble1d_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vdouble1d_t___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
   }
   arg1 = reinterpret_cast< std::vector< double > * >(argp1);
   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vdouble1d_t___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vdouble1d_t___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
   } 
   arg2 = static_cast< std::vector< double >::difference_type >(val2);
   ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vdouble1d_t___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vdouble1d_t___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< double >::difference_type >(val3);
   try {
-    std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+    result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getslice__(arg1,arg2,arg3);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -54830,14 +54714,14 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_0(PyObject *SWIGUNUSED
     SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
   }
   
-  resultobj = SWIG_Py_Void();
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
   std::vector< double >::difference_type arg2 ;
@@ -54872,7 +54756,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_1(PyObject *SWIGUNUSED
   } 
   arg3 = static_cast< std::vector< double >::difference_type >(val3);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res4 = swig::asptr(obj3, &ptr);
     if (!SWIG_IsOK(res4)) {
       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vdouble1d_t___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -54883,7 +54767,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_1(PyObject *SWIGUNUSED
     arg4 = ptr;
   }
   try {
-    std_vector_Sl_double_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
+    std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -54901,21 +54785,69 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+  std::vector< double >::difference_type arg2 ;
+  std::vector< double >::difference_type arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vdouble1d_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vdouble1d_t___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector< double >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vdouble1d_t___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector< double >::difference_type >(val3);
+  try {
+    std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -54928,14 +54860,14 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice__(PyObject *self, PyObject *ar
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vdouble1d_t___setslice____SWIG_0(self, args);
+          return _wrap_vdouble1d_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -54948,10 +54880,10 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice__(PyObject *self, PyObject *ar
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<double,std::allocator< double > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vdouble1d_t___setslice____SWIG_1(self, args);
+            return _wrap_vdouble1d_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -54961,8 +54893,8 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice__(PyObject *self, PyObject *ar
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vdouble1d_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type)\n"
-    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type,std::vector< double,std::allocator< double > > const &)\n");
+    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type,std::vector< double,std::allocator< double > > const &)\n"
+    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type)\n");
   return 0;
 }
 
@@ -55043,9 +54975,6 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_0(PyObject *SWIGUNUSEDP
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -55118,7 +55047,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *SWIGUNUSEDP
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble1d_t___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -55224,20 +55153,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -55250,7 +55179,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem__(PyObject *self, PyObject *arg
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -55310,20 +55239,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -55336,7 +55265,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem__(PyObject *self, PyObject *arg
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -55406,20 +55335,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -55432,14 +55361,14 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble1d_t___setitem____SWIG_0(self, args);
@@ -55449,7 +55378,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -55478,34 +55407,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< double >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_pop" "', argument " "1"" of type '" "std::vector< double > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  try {
-    result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_From_double(static_cast< double >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vdouble1d_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -55560,7 +55461,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble1d_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vdouble1d_t",&obj0)) SWIG_fail;
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vdouble1d_t" "', argument " "1"" of type '" "std::vector< double > const &""'"); 
@@ -55624,6 +55525,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble1d_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_clear" "', argument " "1"" of type '" "std::vector< double > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble1d_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -55657,6 +55579,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble1d_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< double > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+  result = ((std::vector< double > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble1d_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -55749,49 +55693,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_clear" "', argument " "1"" of type '" "std::vector< double > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vdouble1d_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< double > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  result = ((std::vector< double > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vdouble1d_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double >::size_type arg1 ;
@@ -55957,20 +55858,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -55983,7 +55884,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t_erase(PyObject *self, PyObject *args) {
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -56043,14 +55944,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vdouble1d_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -56069,7 +55970,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble1d_t(PyObject *self, PyObject *args) {
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vdouble1d_t__SWIG_1(self, args);
@@ -56262,20 +56163,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -56289,7 +56190,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t_resize(PyObject *self, PyObject *args) {
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -56423,20 +56324,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -56455,7 +56356,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t_insert(PyObject *self, PyObject *args) {
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -56658,6 +56559,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble2d_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< std::vector< double > >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &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 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_pop" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
+  try {
+    result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble2d_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
@@ -56712,17 +56641,20 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_0(PyObject *SWIGUNUSED
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
   std::vector< std::vector< double > >::difference_type arg2 ;
   std::vector< std::vector< double > >::difference_type arg3 ;
+  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:vdouble2d_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vdouble2d_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &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 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
@@ -56738,8 +56670,19 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_0(PyObject *SWIGUNUSED
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vdouble2d_t___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
+  {
+    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;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vdouble2d_t___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vdouble2d_t___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
   try {
-    std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3);
+    std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg4);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -56749,8 +56692,10 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_0(PyObject *SWIGUNUSED
   }
   
   resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
@@ -56760,20 +56705,17 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_1(PyObject *SWIGUNUSED
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
   std::vector< std::vector< double > >::difference_type arg2 ;
   std::vector< std::vector< double > >::difference_type arg3 ;
-  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vdouble2d_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vdouble2d_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &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 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
@@ -56789,19 +56731,8 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_1(PyObject *SWIGUNUSED
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vdouble2d_t___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
-  {
-    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;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vdouble2d_t___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vdouble2d_t___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
   try {
-    std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg4);
+    std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -56811,29 +56742,27 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_1(PyObject *SWIGUNUSED
   }
   
   resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -56846,14 +56775,14 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice__(PyObject *self, PyObject *ar
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vdouble2d_t___setslice____SWIG_0(self, args);
+          return _wrap_vdouble2d_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -56866,10 +56795,10 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice__(PyObject *self, PyObject *ar
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vdouble2d_t___setslice____SWIG_1(self, args);
+            return _wrap_vdouble2d_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -56879,8 +56808,8 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice__(PyObject *self, PyObject *ar
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vdouble2d_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< std::vector< double > >::__setslice__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::difference_type)\n"
-    "    std::vector< std::vector< double > >::__setslice__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n");
+    "    std::vector< std::vector< double > >::__setslice__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
+    "    std::vector< std::vector< double > >::__setslice__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::difference_type)\n");
   return 0;
 }
 
@@ -56961,9 +56890,6 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_0(PyObject *SWIGUNUSEDP
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -57036,7 +56962,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *SWIGUNUSEDP
     arg2 = (PySliceObject *) obj1;
   }
   {
-    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;
+    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;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
@@ -57142,20 +57068,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -57168,7 +57094,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem__(PyObject *self, PyObject *arg
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -57220,7 +57146,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_1(PyObject *SWIGUNUSEDP
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
   
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(*result));
   return resultobj;
 fail:
   return NULL;
@@ -57228,20 +57154,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -57254,7 +57180,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem__(PyObject *self, PyObject *arg
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -57302,7 +57228,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_2(PyObject *SWIGUNUSEDP
   } 
   arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -57329,20 +57255,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -57355,14 +57281,14 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble2d_t___setitem____SWIG_0(self, args);
@@ -57372,7 +57298,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -57380,7 +57306,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
         _v = SWIG_CheckState(res);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble2d_t___setitem____SWIG_2(self, args);
@@ -57399,34 +57325,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble2d_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< std::vector< double > >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &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 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_pop" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
-  try {
-    result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vdouble2d_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
@@ -57444,7 +57342,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_append(PyObject *SWIGUNUSEDPARM(self), Py
   }
   arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vdouble2d_t_append" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -57486,7 +57384,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble2d_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vdouble2d_t",&obj0)) SWIG_fail;
   {
-    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;
+    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;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vdouble2d_t" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const &""'"); 
@@ -57550,6 +57448,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble2d_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &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 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_clear" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble2d_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
@@ -57583,6 +57502,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble2d_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< std::vector< double,std::allocator< double > > > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &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 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
+  result = ((std::vector< std::vector< double > > const *)arg1)->get_allocator();
+  resultobj = 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 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble2d_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
@@ -57675,49 +57616,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble2d_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &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 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_clear" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vdouble2d_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< std::vector< double,std::allocator< double > > > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &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 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
-  result = ((std::vector< std::vector< double > > const *)arg1)->get_allocator();
-  resultobj = 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 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vdouble2d_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > >::size_type arg1 ;
@@ -57883,20 +57781,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -57909,7 +57807,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_erase(PyObject *self, PyObject *args) {
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -57953,7 +57851,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble2d_t__SWIG_3(PyObject *SWIGUNUSEDPARM(self
   } 
   arg1 = static_cast< std::vector< std::vector< double > >::size_type >(val1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_vdouble2d_t" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -57974,14 +57872,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vdouble2d_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -58000,7 +57898,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble2d_t(PyObject *self, PyObject *args) {
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vdouble2d_t__SWIG_1(self, args);
@@ -58013,7 +57911,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble2d_t(PyObject *self, PyObject *args) {
       _v = SWIG_CheckState(res);
     }
     if (_v) {
-      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
+      int res = swig::asptr(argv[1], (std::vector<double,std::allocator< double > >**)(0));
       _v = SWIG_CheckState(res);
       if (_v) {
         return _wrap_new_vdouble2d_t__SWIG_3(self, args);
@@ -58049,7 +57947,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_push_back(PyObject *SWIGUNUSEDPARM(self),
   }
   arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vdouble2d_t_push_back" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -58084,7 +57982,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_front(PyObject *SWIGUNUSEDPARM(self), PyO
   }
   arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
   result = (std::vector< std::vector< double > >::value_type *) &((std::vector< std::vector< double > > const *)arg1)->front();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(*result));
   return resultobj;
 fail:
   return NULL;
@@ -58106,7 +58004,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_back(PyObject *SWIGUNUSEDPARM(self), PyOb
   }
   arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
   result = (std::vector< std::vector< double > >::value_type *) &((std::vector< std::vector< double > > const *)arg1)->back();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(*result));
   return resultobj;
 fail:
   return NULL;
@@ -58139,7 +58037,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_assign(PyObject *SWIGUNUSEDPARM(self), Py
   } 
   arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t_assign" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -58185,7 +58083,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(s
   } 
   arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t_resize" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -58206,20 +58104,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -58233,7 +58131,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_resize(PyObject *self, PyObject *args) {
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -58241,7 +58139,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_resize(PyObject *self, PyObject *args) {
         _v = SWIG_CheckState(res);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble2d_t_resize__SWIG_1(self, args);
@@ -58292,7 +58190,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(s
     }
   }
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t_insert" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -58354,7 +58252,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(s
   } 
   arg3 = static_cast< std::vector< std::vector< double > >::size_type >(val3);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res4 = swig::asptr(obj3, &ptr);
     if (!SWIG_IsOK(res4)) {
       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vdouble2d_t_insert" "', argument " "4"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -58375,27 +58273,27 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble2d_t_insert__SWIG_0(self, args);
@@ -58405,7 +58303,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_insert(PyObject *self, PyObject *args) {
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -58417,7 +58315,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_insert(PyObject *self, PyObject *args) {
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<double,std::allocator< double > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
             return _wrap_vdouble2d_t_insert__SWIG_1(self, args);
@@ -58606,6 +58504,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_integer_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< int >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_pop" "', argument " "1"" of type '" "std::vector< int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  try {
+    result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_integer_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
@@ -58660,17 +58586,20 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_0(PyObject *SWIGU
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
   std::vector< int >::difference_type arg2 ;
   std::vector< int >::difference_type arg3 ;
+  std::vector< int,std::allocator< int > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:vector_integer_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_integer_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
@@ -58686,8 +58615,19 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_0(PyObject *SWIGU
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_integer_t___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< int >::difference_type >(val3);
+  {
+    std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_integer_t___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_integer_t___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
   try {
-    std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+    std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -58697,8 +58637,10 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_0(PyObject *SWIGU
   }
   
   resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
@@ -58708,20 +58650,17 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_1(PyObject *SWIGU
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
   std::vector< int >::difference_type arg2 ;
   std::vector< int >::difference_type arg3 ;
-  std::vector< int,std::allocator< int > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_integer_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vector_integer_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
@@ -58737,19 +58676,8 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_1(PyObject *SWIGU
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_integer_t___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< int >::difference_type >(val3);
-  {
-    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_integer_t___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_integer_t___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
   try {
-    std_vector_Sl_int_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
+    std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,arg2,arg3);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -58759,29 +58687,27 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_1(PyObject *SWIGU
   }
   
   resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -58794,14 +58720,14 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_integer_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_integer_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -58814,10 +58740,10 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<int,std::allocator< int > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_integer_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_integer_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -58827,8 +58753,8 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice__(PyObject *self, PyObjec
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_integer_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type)\n"
-    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type,std::vector< int,std::allocator< int > > const &)\n");
+    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type,std::vector< int,std::allocator< int > > const &)\n"
+    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type)\n");
   return 0;
 }
 
@@ -58909,9 +58835,6 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_0(PyObject *SWIGUN
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -58984,7 +58907,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *SWIGUN
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
+    std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_integer_t___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
@@ -59090,20 +59013,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -59116,7 +59039,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___delitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -59176,20 +59099,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -59202,7 +59125,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -59272,20 +59195,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -59298,14 +59221,14 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<int,std::allocator< int > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_integer_t___setitem____SWIG_0(self, args);
@@ -59315,7 +59238,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -59344,34 +59267,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_integer_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< int >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_pop" "', argument " "1"" of type '" "std::vector< int > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
-  try {
-    result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_From_int(static_cast< int >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_integer_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
@@ -59426,7 +59321,7 @@ SWIGINTERN PyObject *_wrap_new_vector_integer_t__SWIG_1(PyObject *SWIGUNUSEDPARM
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_integer_t",&obj0)) SWIG_fail;
   {
-    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
+    std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_integer_t" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
@@ -59490,6 +59385,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_integer_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_integer_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
@@ -59523,6 +59439,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_integer_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< int > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  result = ((std::vector< int > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_integer_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
@@ -59615,49 +59553,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_integer_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_integer_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< int > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
-  result = ((std::vector< int > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vector_integer_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int >::size_type arg1 ;
@@ -59823,20 +59718,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -59849,7 +59744,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t_erase(PyObject *self, PyObject *args
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -59909,14 +59804,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_integer_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -59935,7 +59830,7 @@ SWIGINTERN PyObject *_wrap_new_vector_integer_t(PyObject *self, PyObject *args)
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_integer_t__SWIG_1(self, args);
@@ -60128,20 +60023,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -60155,7 +60050,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t_resize(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -60289,20 +60184,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -60321,7 +60216,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t_insert(PyObject *self, PyObject *arg
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -60524,6 +60419,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_longinteger_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< unsigned long >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_pop" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
+  try {
+    result = (std::vector< unsigned long >::value_type)std_vector_Sl_unsigned_SS_long_Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
@@ -60578,17 +60501,20 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_0(PyObject *S
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
   std::vector< unsigned long >::difference_type arg2 ;
   std::vector< unsigned long >::difference_type arg3 ;
+  std::vector< unsigned long,std::allocator< unsigned long > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:vector_longinteger_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_longinteger_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t___setslice__" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
@@ -60604,8 +60530,19 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_0(PyObject *S
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_longinteger_t___setslice__" "', argument " "3"" of type '" "std::vector< unsigned long >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< unsigned long >::difference_type >(val3);
+  {
+    std::vector<unsigned long,std::allocator< unsigned long > > *ptr = (std::vector<unsigned long,std::allocator< unsigned long > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_longinteger_t___setslice__" "', argument " "4"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_longinteger_t___setslice__" "', argument " "4"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
   try {
-    std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+    std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< unsigned long,std::allocator< unsigned long > > const &)*arg4);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -60615,8 +60552,10 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_0(PyObject *S
   }
   
   resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
@@ -60626,20 +60565,17 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_1(PyObject *S
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
   std::vector< unsigned long >::difference_type arg2 ;
   std::vector< unsigned long >::difference_type arg3 ;
-  std::vector< unsigned long,std::allocator< unsigned long > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_longinteger_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vector_longinteger_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t___setslice__" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
@@ -60655,19 +60591,8 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_1(PyObject *S
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_longinteger_t___setslice__" "', argument " "3"" of type '" "std::vector< unsigned long >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< unsigned long >::difference_type >(val3);
-  {
-    std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_longinteger_t___setslice__" "', argument " "4"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_longinteger_t___setslice__" "', argument " "4"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
   try {
-    std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< unsigned long,std::allocator< unsigned long > > const &)*arg4);
+    std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_0(arg1,arg2,arg3);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -60677,29 +60602,27 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_1(PyObject *S
   }
   
   resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -60712,14 +60635,14 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice__(PyObject *self, PyO
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_longinteger_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_longinteger_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -60732,10 +60655,10 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice__(PyObject *self, PyO
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_longinteger_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_longinteger_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -60745,8 +60668,8 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice__(PyObject *self, PyO
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_longinteger_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< unsigned long >::__setslice__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::difference_type)\n"
-    "    std::vector< unsigned long >::__setslice__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::difference_type,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n");
+    "    std::vector< unsigned long >::__setslice__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::difference_type,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
+    "    std::vector< unsigned long >::__setslice__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::difference_type)\n");
   return 0;
 }
 
@@ -60827,9 +60750,6 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_0(PyObject *SW
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -60902,7 +60822,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *SW
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
+    std::vector<unsigned long,std::allocator< unsigned long > > *ptr = (std::vector<unsigned long,std::allocator< unsigned long > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_longinteger_t___setitem__" "', argument " "3"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
@@ -61008,20 +60928,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -61034,7 +60954,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem__(PyObject *self, PyOb
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -61094,20 +61014,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -61120,7 +61040,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem__(PyObject *self, PyOb
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -61190,20 +61110,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -61216,14 +61136,14 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyOb
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_longinteger_t___setitem____SWIG_0(self, args);
@@ -61233,7 +61153,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyOb
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -61262,34 +61182,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_longinteger_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< unsigned long >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_pop" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
-  try {
-    result = (std::vector< unsigned long >::value_type)std_vector_Sl_unsigned_SS_long_Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
@@ -61344,7 +61236,7 @@ SWIGINTERN PyObject *_wrap_new_vector_longinteger_t__SWIG_1(PyObject *SWIGUNUSED
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_longinteger_t",&obj0)) SWIG_fail;
   {
-    std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
+    std::vector<unsigned long,std::allocator< unsigned long > > *ptr = (std::vector<unsigned long,std::allocator< unsigned long > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_longinteger_t" "', argument " "1"" of type '" "std::vector< unsigned long > const &""'"); 
@@ -61408,6 +61300,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_longinteger_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_clear" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
@@ -61441,6 +61354,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_longinteger_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< unsigned long > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_get_allocator" "', argument " "1"" of type '" "std::vector< unsigned long > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
+  result = ((std::vector< unsigned long > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< unsigned long >::allocator_type(static_cast< const std::vector< unsigned long >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_unsigned_long_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
@@ -61533,49 +61468,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_longinteger_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_clear" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_longinteger_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< unsigned long > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_get_allocator" "', argument " "1"" of type '" "std::vector< unsigned long > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
-  result = ((std::vector< unsigned long > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< unsigned long >::allocator_type(static_cast< const std::vector< unsigned long >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_unsigned_long_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vector_longinteger_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long >::size_type arg1 ;
@@ -61741,20 +61633,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -61767,7 +61659,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t_erase(PyObject *self, PyObject *
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -61827,14 +61719,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_longinteger_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -61853,7 +61745,7 @@ SWIGINTERN PyObject *_wrap_new_vector_longinteger_t(PyObject *self, PyObject *ar
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_longinteger_t__SWIG_1(self, args);
@@ -62046,20 +61938,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -62073,7 +61965,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t_resize(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -62207,20 +62099,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -62239,7 +62131,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t_insert(PyObject *self, PyObject
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -62442,6 +62334,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_complex_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< std::complex< double > >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_pop" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
+  try {
+    result = std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_complex_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
@@ -62492,6 +62412,70 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
+  std::vector< std::complex< double > >::difference_type arg2 ;
+  std::vector< std::complex< double > >::difference_type arg3 ;
+  std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_complex_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t___setslice__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_complex_t___setslice__" "', argument " "2"" of type '" "std::vector< std::complex< double > >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector< std::complex< double > >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_complex_t___setslice__" "', argument " "3"" of type '" "std::vector< std::complex< double > >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector< std::complex< double > >::difference_type >(val3);
+  {
+    std::vector<std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector<std::complex< double >,std::allocator< std::complex< double > > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_complex_t___setslice__" "', argument " "4"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_complex_t___setslice__" "', argument " "4"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  try {
+    std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)*arg4);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vector_complex_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
   std::vector< std::complex< double > >::difference_type arg2 ;
@@ -62539,85 +62523,21 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_complex_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
-  std::vector< std::complex< double > >::difference_type arg2 ;
-  std::vector< std::complex< double > >::difference_type arg3 ;
-  std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg4 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  ptrdiff_t val3 ;
-  int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_complex_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t___setslice__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_complex_t___setslice__" "', argument " "2"" of type '" "std::vector< std::complex< double > >::difference_type""'");
-  } 
-  arg2 = static_cast< std::vector< std::complex< double > >::difference_type >(val2);
-  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_complex_t___setslice__" "', argument " "3"" of type '" "std::vector< std::complex< double > >::difference_type""'");
-  } 
-  arg3 = static_cast< std::vector< std::complex< double > >::difference_type >(val3);
-  {
-    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_complex_t___setslice__" "', argument " "4"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_complex_t___setslice__" "', argument " "4"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
-  try {
-    std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)*arg4);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return resultobj;
-fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_complex_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -62630,14 +62550,14 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_complex_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_complex_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -62650,10 +62570,10 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_complex_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_complex_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -62663,8 +62583,8 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice__(PyObject *self, PyObjec
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_complex_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< std::complex< double > >::__setslice__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::difference_type)\n"
-    "    std::vector< std::complex< double > >::__setslice__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n");
+    "    std::vector< std::complex< double > >::__setslice__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
+    "    std::vector< std::complex< double > >::__setslice__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::difference_type)\n");
   return 0;
 }
 
@@ -62745,9 +62665,6 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_0(PyObject *SWIGUN
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -62820,7 +62737,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *SWIGUN
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
+    std::vector<std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector<std::complex< double >,std::allocator< std::complex< double > > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_complex_t___setitem__" "', argument " "3"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
@@ -62926,20 +62843,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -62952,7 +62869,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___delitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -63012,20 +62929,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -63038,7 +62955,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -63108,20 +63025,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -63134,14 +63051,14 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_complex_t___setitem____SWIG_0(self, args);
@@ -63151,7 +63068,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -63180,34 +63097,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_complex_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< std::complex< double > >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_pop" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  try {
-    result = std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_complex_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
@@ -63262,7 +63151,7 @@ SWIGINTERN PyObject *_wrap_new_vector_complex_t__SWIG_1(PyObject *SWIGUNUSEDPARM
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_complex_t",&obj0)) SWIG_fail;
   {
-    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
+    std::vector<std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector<std::complex< double >,std::allocator< std::complex< double > > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_complex_t" "', argument " "1"" of type '" "std::vector< std::complex< double > > const &""'"); 
@@ -63326,6 +63215,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_complex_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_clear" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_complex_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
@@ -63359,6 +63269,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_complex_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< std::complex< double > > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
+  result = ((std::vector< std::complex< double > > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< std::complex< double > >::allocator_type(static_cast< const std::vector< std::complex< double > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__complexT_double_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_complex_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
@@ -63451,49 +63383,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_complex_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_clear" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_complex_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< std::complex< double > > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  result = ((std::vector< std::complex< double > > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< std::complex< double > >::allocator_type(static_cast< const std::vector< std::complex< double > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__complexT_double_t_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vector_complex_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > >::size_type arg1 ;
@@ -63659,20 +63548,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -63685,7 +63574,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t_erase(PyObject *self, PyObject *args
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -63745,14 +63634,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_complex_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -63771,7 +63660,7 @@ SWIGINTERN PyObject *_wrap_new_vector_complex_t(PyObject *self, PyObject *args)
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_complex_t__SWIG_1(self, args);
@@ -63964,20 +63853,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -63991,7 +63880,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t_resize(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -64125,20 +64014,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -64157,7 +64046,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t_insert(PyObject *self, PyObject *arg
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -64360,6 +64249,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_string_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< std::string >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_pop" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
+  try {
+    result = std_vector_Sl_std_string_Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_string_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
@@ -64410,6 +64327,70 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
+  std::vector< std::string >::difference_type arg2 ;
+  std::vector< std::string >::difference_type arg3 ;
+  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_string_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string_t___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_string_t___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
+  {
+    std::vector<std::string,std::allocator< std::string > > *ptr = (std::vector<std::string,std::allocator< std::string > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_string_t___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_t___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  try {
+    std_vector_Sl_std_string_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vector_string_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
   std::vector< std::string >::difference_type arg2 ;
@@ -64457,85 +64438,21 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_string_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
-  std::vector< std::string >::difference_type arg2 ;
-  std::vector< std::string >::difference_type arg3 ;
-  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  ptrdiff_t val3 ;
-  int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_string_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string_t___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
-  } 
-  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
-  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_string_t___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
-  } 
-  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
-  {
-    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_string_t___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_t___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
-  try {
-    std_vector_Sl_std_string_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return resultobj;
-fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_string_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -64548,14 +64465,14 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice__(PyObject *self, PyObject
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_string_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_string_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -64568,10 +64485,10 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice__(PyObject *self, PyObject
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< std::string,std::allocator< std::string > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<std::string,std::allocator< std::string > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_string_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_string_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -64581,8 +64498,8 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice__(PyObject *self, PyObject
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_string_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type)\n"
-    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type,std::vector< std::string,std::allocator< std::string > > const &)\n");
+    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type,std::vector< std::string,std::allocator< std::string > > const &)\n"
+    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type)\n");
   return 0;
 }
 
@@ -64663,9 +64580,6 @@ SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_0(PyObject *SWIGUNU
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -64738,7 +64652,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *SWIGUNU
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
+    std::vector<std::string,std::allocator< std::string > > *ptr = (std::vector<std::string,std::allocator< std::string > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_string_t___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
@@ -64844,20 +64758,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -64870,7 +64784,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___delitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -64930,20 +64844,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -64956,7 +64870,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -65031,20 +64945,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -65057,14 +64971,14 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<std::string,std::allocator< std::string > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_string_t___setitem____SWIG_0(self, args);
@@ -65074,7 +64988,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -65101,34 +65015,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_string_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< std::string >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_pop" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
-  try {
-    result = std_vector_Sl_std_string_Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_string_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
@@ -65188,7 +65074,7 @@ SWIGINTERN PyObject *_wrap_new_vector_string_t__SWIG_1(PyObject *SWIGUNUSEDPARM(
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_string_t",&obj0)) SWIG_fail;
   {
-    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
+    std::vector<std::string,std::allocator< std::string > > *ptr = (std::vector<std::string,std::allocator< std::string > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_string_t" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
@@ -65252,6 +65138,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_string_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_clear" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_string_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
@@ -65285,6 +65192,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_string_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< std::string > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
+  result = ((std::vector< std::string > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< std::string >::allocator_type(static_cast< const std::vector< std::string >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_string_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
@@ -65377,49 +65306,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_string_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_clear" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_string_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< std::string > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
-  result = ((std::vector< std::string > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< std::string >::allocator_type(static_cast< const std::vector< std::string >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vector_string_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string >::size_type arg1 ;
@@ -65585,20 +65471,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -65611,7 +65497,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t_erase(PyObject *self, PyObject *args)
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -65676,14 +65562,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_string_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -65702,7 +65588,7 @@ SWIGINTERN PyObject *_wrap_new_vector_string_t(PyObject *self, PyObject *args) {
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_string_t__SWIG_1(self, args);
@@ -65908,20 +65794,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -65935,7 +65821,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t_resize(PyObject *self, PyObject *args
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -66077,20 +65963,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -66107,7 +65993,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t_insert(PyObject *self, PyObject *args
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -67028,14 +66914,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_INamed(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -67204,14 +67090,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_INamedShared(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -67449,14 +67335,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_IParameterized(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -67691,14 +67577,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IParameterized_registerParameter(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -67938,14 +67824,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IParameterized_addParametersToExternalPool(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -68161,14 +68047,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_ParameterPattern(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -68423,14 +68309,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_IParameterizedShared(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -68842,14 +68728,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IParameterizedShared_addParametersToExternalPool(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -69146,14 +69032,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IParameterizedShared_registerParameter(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -69491,14 +69377,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_kvector_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -70475,6 +70361,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_kvector_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< Geometry::BasicVector3D< double > > *arg1 = (std::vector< Geometry::BasicVector3D< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< Geometry::BasicVector3D< double > >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_kvector_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_double_t_std__allocatorT_Geometry__BasicVector3DT_double_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_kvector_t_pop" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< double > > * >(argp1);
+  try {
+    result = std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_NewPointerObj((new std::vector< Geometry::BasicVector3D< double > >::value_type(static_cast< const std::vector< Geometry::BasicVector3D< double > >::value_type& >(result))), SWIGTYPE_p_Geometry__BasicVector3DT_double_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_kvector_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< Geometry::BasicVector3D< double > > *arg1 = (std::vector< Geometry::BasicVector3D< double > > *) 0 ;
@@ -70525,6 +70439,70 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_kvector_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< Geometry::BasicVector3D< double > > *arg1 = (std::vector< Geometry::BasicVector3D< double > > *) 0 ;
+  std::vector< Geometry::BasicVector3D< double > >::difference_type arg2 ;
+  std::vector< Geometry::BasicVector3D< double > >::difference_type arg3 ;
+  std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_kvector_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_double_t_std__allocatorT_Geometry__BasicVector3DT_double_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_kvector_t___setslice__" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< double > > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_kvector_t___setslice__" "', argument " "2"" of type '" "std::vector< Geometry::BasicVector3D< double > >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector< Geometry::BasicVector3D< double > >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_kvector_t___setslice__" "', argument " "3"" of type '" "std::vector< Geometry::BasicVector3D< double > >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector< Geometry::BasicVector3D< double > >::difference_type >(val3);
+  {
+    std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *ptr = (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_kvector_t___setslice__" "', argument " "4"" of type '" "std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_kvector_t___setslice__" "', argument " "4"" of type '" "std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  try {
+    std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > const &)*arg4);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vector_kvector_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< Geometry::BasicVector3D< double > > *arg1 = (std::vector< Geometry::BasicVector3D< double > > *) 0 ;
   std::vector< Geometry::BasicVector3D< double > >::difference_type arg2 ;
@@ -70572,85 +70550,21 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_kvector_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< Geometry::BasicVector3D< double > > *arg1 = (std::vector< Geometry::BasicVector3D< double > > *) 0 ;
-  std::vector< Geometry::BasicVector3D< double > >::difference_type arg2 ;
-  std::vector< Geometry::BasicVector3D< double > >::difference_type arg3 ;
-  std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *arg4 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  ptrdiff_t val3 ;
-  int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_kvector_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_double_t_std__allocatorT_Geometry__BasicVector3DT_double_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_kvector_t___setslice__" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< double > > * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_kvector_t___setslice__" "', argument " "2"" of type '" "std::vector< Geometry::BasicVector3D< double > >::difference_type""'");
-  } 
-  arg2 = static_cast< std::vector< Geometry::BasicVector3D< double > >::difference_type >(val2);
-  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_kvector_t___setslice__" "', argument " "3"" of type '" "std::vector< Geometry::BasicVector3D< double > >::difference_type""'");
-  } 
-  arg3 = static_cast< std::vector< Geometry::BasicVector3D< double > >::difference_type >(val3);
-  {
-    std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *ptr = (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_kvector_t___setslice__" "', argument " "4"" of type '" "std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_kvector_t___setslice__" "', argument " "4"" of type '" "std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
-  try {
-    std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > const &)*arg4);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return resultobj;
-fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_kvector_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -70663,14 +70577,14 @@ SWIGINTERN PyObject *_wrap_vector_kvector_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_kvector_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_kvector_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -70683,10 +70597,10 @@ SWIGINTERN PyObject *_wrap_vector_kvector_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_kvector_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_kvector_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -70696,8 +70610,8 @@ SWIGINTERN PyObject *_wrap_vector_kvector_t___setslice__(PyObject *self, PyObjec
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_kvector_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< Geometry::BasicVector3D< double > >::__setslice__(std::vector< Geometry::BasicVector3D< double > >::difference_type,std::vector< Geometry::BasicVector3D< double > >::difference_type)\n"
-    "    std::vector< Geometry::BasicVector3D< double > >::__setslice__(std::vector< Geometry::BasicVector3D< double > >::difference_type,std::vector< Geometry::BasicVector3D< double > >::difference_type,std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > const &)\n");
+    "    std::vector< Geometry::BasicVector3D< double > >::__setslice__(std::vector< Geometry::BasicVector3D< double > >::difference_type,std::vector< Geometry::BasicVector3D< double > >::difference_type,std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > const &)\n"
+    "    std::vector< Geometry::BasicVector3D< double > >::__setslice__(std::vector< Geometry::BasicVector3D< double > >::difference_type,std::vector< Geometry::BasicVector3D< double > >::difference_type)\n");
   return 0;
 }
 
@@ -70778,9 +70692,6 @@ SWIGINTERN PyObject *_wrap_vector_kvector_t___delitem____SWIG_0(PyObject *SWIGUN
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -70853,7 +70764,7 @@ SWIGINTERN PyObject *_wrap_vector_kvector_t___setitem____SWIG_0(PyObject *SWIGUN
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *ptr = (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *)0;
+    std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *ptr = (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_kvector_t___setitem__" "', argument " "3"" of type '" "std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > const &""'"); 
@@ -70959,20 +70870,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_kvector_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -70985,7 +70896,7 @@ SWIGINTERN PyObject *_wrap_vector_kvector_t___delitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -71045,20 +70956,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_kvector_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -71071,7 +70982,7 @@ SWIGINTERN PyObject *_wrap_vector_kvector_t___getitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -71142,20 +71053,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_kvector_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -71168,14 +71079,14 @@ SWIGINTERN PyObject *_wrap_vector_kvector_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_kvector_t___setitem____SWIG_0(self, args);
@@ -71185,7 +71096,7 @@ SWIGINTERN PyObject *_wrap_vector_kvector_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -71212,34 +71123,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_kvector_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< Geometry::BasicVector3D< double > > *arg1 = (std::vector< Geometry::BasicVector3D< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< Geometry::BasicVector3D< double > >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_kvector_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_double_t_std__allocatorT_Geometry__BasicVector3DT_double_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_kvector_t_pop" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< double > > * >(argp1);
-  try {
-    result = std_vector_Sl_Geometry_BasicVector3D_Sl_double_Sg__Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_NewPointerObj((new std::vector< Geometry::BasicVector3D< double > >::value_type(static_cast< const std::vector< Geometry::BasicVector3D< double > >::value_type& >(result))), SWIGTYPE_p_Geometry__BasicVector3DT_double_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_kvector_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< Geometry::BasicVector3D< double > > *arg1 = (std::vector< Geometry::BasicVector3D< double > > *) 0 ;
@@ -71295,7 +71178,7 @@ SWIGINTERN PyObject *_wrap_new_vector_kvector_t__SWIG_1(PyObject *SWIGUNUSEDPARM
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_kvector_t",&obj0)) SWIG_fail;
   {
-    std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *ptr = (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *)0;
+    std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *ptr = (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_kvector_t" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< double > > const &""'"); 
@@ -71359,6 +71242,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_kvector_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< Geometry::BasicVector3D< double > > *arg1 = (std::vector< Geometry::BasicVector3D< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_kvector_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_double_t_std__allocatorT_Geometry__BasicVector3DT_double_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_kvector_t_clear" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< double > > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_kvector_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< Geometry::BasicVector3D< double > > *arg1 = (std::vector< Geometry::BasicVector3D< double > > *) 0 ;
@@ -71392,6 +71296,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_kvector_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< Geometry::BasicVector3D< double > > *arg1 = (std::vector< Geometry::BasicVector3D< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< Geometry::BasicVector3D< double > > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_kvector_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_double_t_std__allocatorT_Geometry__BasicVector3DT_double_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_kvector_t_get_allocator" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< double > > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< double > > * >(argp1);
+  result = ((std::vector< Geometry::BasicVector3D< double > > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< Geometry::BasicVector3D< double > >::allocator_type(static_cast< const std::vector< Geometry::BasicVector3D< double > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Geometry__BasicVector3DT_double_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_kvector_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< Geometry::BasicVector3D< double > > *arg1 = (std::vector< Geometry::BasicVector3D< double > > *) 0 ;
@@ -71484,49 +71410,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_kvector_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< Geometry::BasicVector3D< double > > *arg1 = (std::vector< Geometry::BasicVector3D< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_kvector_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_double_t_std__allocatorT_Geometry__BasicVector3DT_double_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_kvector_t_clear" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< double > > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_kvector_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< Geometry::BasicVector3D< double > > *arg1 = (std::vector< Geometry::BasicVector3D< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< Geometry::BasicVector3D< double > > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_kvector_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_double_t_std__allocatorT_Geometry__BasicVector3DT_double_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_kvector_t_get_allocator" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< double > > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< double > > * >(argp1);
-  result = ((std::vector< Geometry::BasicVector3D< double > > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< Geometry::BasicVector3D< double > >::allocator_type(static_cast< const std::vector< Geometry::BasicVector3D< double > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Geometry__BasicVector3DT_double_t_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vector_kvector_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< Geometry::BasicVector3D< double > >::size_type arg1 ;
@@ -71692,20 +71575,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_kvector_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -71718,7 +71601,7 @@ SWIGINTERN PyObject *_wrap_vector_kvector_t_erase(PyObject *self, PyObject *args
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -71779,14 +71662,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_kvector_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -71805,7 +71688,7 @@ SWIGINTERN PyObject *_wrap_new_vector_kvector_t(PyObject *self, PyObject *args)
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_kvector_t__SWIG_1(self, args);
@@ -71999,20 +71882,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_kvector_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -72026,7 +71909,7 @@ SWIGINTERN PyObject *_wrap_vector_kvector_t_resize(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -72160,20 +72043,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_kvector_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -72190,7 +72073,7 @@ SWIGINTERN PyObject *_wrap_vector_kvector_t_insert(PyObject *self, PyObject *arg
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -72355,14 +72238,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_cvector_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -73065,6 +72948,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_cvector_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< Geometry::BasicVector3D< std::complex< double > > > *arg1 = (std::vector< Geometry::BasicVector3D< std::complex< double > > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< Geometry::BasicVector3D< std::complex< double > > >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_cvector_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_std__complexT_double_t_t_std__allocatorT_Geometry__BasicVector3DT_std__complexT_double_t_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_cvector_t_pop" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< std::complex< double > > > * >(argp1);
+  try {
+    result = std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_NewPointerObj((new std::vector< Geometry::BasicVector3D< std::complex< double > > >::value_type(static_cast< const std::vector< Geometry::BasicVector3D< std::complex< double > > >::value_type& >(result))), SWIGTYPE_p_Geometry__BasicVector3DT_std__complexT_double_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_cvector_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< Geometry::BasicVector3D< std::complex< double > > > *arg1 = (std::vector< Geometry::BasicVector3D< std::complex< double > > > *) 0 ;
@@ -73115,6 +73026,70 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_cvector_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< Geometry::BasicVector3D< std::complex< double > > > *arg1 = (std::vector< Geometry::BasicVector3D< std::complex< double > > > *) 0 ;
+  std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type arg2 ;
+  std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type arg3 ;
+  std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_cvector_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_std__complexT_double_t_t_std__allocatorT_Geometry__BasicVector3DT_std__complexT_double_t_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_cvector_t___setslice__" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< std::complex< double > > > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_cvector_t___setslice__" "', argument " "2"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_cvector_t___setslice__" "', argument " "3"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type >(val3);
+  {
+    std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *ptr = (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_cvector_t___setslice__" "', argument " "4"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_cvector_t___setslice__" "', argument " "4"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  try {
+    std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > const &)*arg4);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vector_cvector_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< Geometry::BasicVector3D< std::complex< double > > > *arg1 = (std::vector< Geometry::BasicVector3D< std::complex< double > > > *) 0 ;
   std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type arg2 ;
@@ -73162,85 +73137,21 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_cvector_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< Geometry::BasicVector3D< std::complex< double > > > *arg1 = (std::vector< Geometry::BasicVector3D< std::complex< double > > > *) 0 ;
-  std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type arg2 ;
-  std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type arg3 ;
-  std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *arg4 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  ptrdiff_t val3 ;
-  int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_cvector_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_std__complexT_double_t_t_std__allocatorT_Geometry__BasicVector3DT_std__complexT_double_t_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_cvector_t___setslice__" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< std::complex< double > > > * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_cvector_t___setslice__" "', argument " "2"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type""'");
-  } 
-  arg2 = static_cast< std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type >(val2);
-  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_cvector_t___setslice__" "', argument " "3"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type""'");
-  } 
-  arg3 = static_cast< std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type >(val3);
-  {
-    std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *ptr = (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_cvector_t___setslice__" "', argument " "4"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_cvector_t___setslice__" "', argument " "4"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
-  try {
-    std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > const &)*arg4);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return resultobj;
-fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_cvector_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -73253,14 +73164,14 @@ SWIGINTERN PyObject *_wrap_vector_cvector_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_cvector_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_cvector_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -73273,10 +73184,10 @@ SWIGINTERN PyObject *_wrap_vector_cvector_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_cvector_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_cvector_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -73286,8 +73197,8 @@ SWIGINTERN PyObject *_wrap_vector_cvector_t___setslice__(PyObject *self, PyObjec
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_cvector_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< Geometry::BasicVector3D< std::complex< double > > >::__setslice__(std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type)\n"
-    "    std::vector< Geometry::BasicVector3D< std::complex< double > > >::__setslice__(std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type,std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > const &)\n");
+    "    std::vector< Geometry::BasicVector3D< std::complex< double > > >::__setslice__(std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type,std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > const &)\n"
+    "    std::vector< Geometry::BasicVector3D< std::complex< double > > >::__setslice__(std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type,std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type)\n");
   return 0;
 }
 
@@ -73368,9 +73279,6 @@ SWIGINTERN PyObject *_wrap_vector_cvector_t___delitem____SWIG_0(PyObject *SWIGUN
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -73443,7 +73351,7 @@ SWIGINTERN PyObject *_wrap_vector_cvector_t___setitem____SWIG_0(PyObject *SWIGUN
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *ptr = (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *)0;
+    std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *ptr = (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_cvector_t___setitem__" "', argument " "3"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > const &""'"); 
@@ -73549,20 +73457,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_cvector_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -73575,7 +73483,7 @@ SWIGINTERN PyObject *_wrap_vector_cvector_t___delitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -73635,20 +73543,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_cvector_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -73661,7 +73569,7 @@ SWIGINTERN PyObject *_wrap_vector_cvector_t___getitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -73732,20 +73640,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_cvector_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -73758,14 +73666,14 @@ SWIGINTERN PyObject *_wrap_vector_cvector_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_cvector_t___setitem____SWIG_0(self, args);
@@ -73775,7 +73683,7 @@ SWIGINTERN PyObject *_wrap_vector_cvector_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -73802,34 +73710,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_cvector_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< Geometry::BasicVector3D< std::complex< double > > > *arg1 = (std::vector< Geometry::BasicVector3D< std::complex< double > > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< Geometry::BasicVector3D< std::complex< double > > >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_cvector_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_std__complexT_double_t_t_std__allocatorT_Geometry__BasicVector3DT_std__complexT_double_t_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_cvector_t_pop" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< std::complex< double > > > * >(argp1);
-  try {
-    result = std_vector_Sl_Geometry_BasicVector3D_Sl_std_complex_Sl_double_Sg__Sg__Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_NewPointerObj((new std::vector< Geometry::BasicVector3D< std::complex< double > > >::value_type(static_cast< const std::vector< Geometry::BasicVector3D< std::complex< double > > >::value_type& >(result))), SWIGTYPE_p_Geometry__BasicVector3DT_std__complexT_double_t_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_cvector_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< Geometry::BasicVector3D< std::complex< double > > > *arg1 = (std::vector< Geometry::BasicVector3D< std::complex< double > > > *) 0 ;
@@ -73885,7 +73765,7 @@ SWIGINTERN PyObject *_wrap_new_vector_cvector_t__SWIG_1(PyObject *SWIGUNUSEDPARM
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_cvector_t",&obj0)) SWIG_fail;
   {
-    std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *ptr = (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *)0;
+    std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *ptr = (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_cvector_t" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > > > const &""'"); 
@@ -73949,6 +73829,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_cvector_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< Geometry::BasicVector3D< std::complex< double > > > *arg1 = (std::vector< Geometry::BasicVector3D< std::complex< double > > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_cvector_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_std__complexT_double_t_t_std__allocatorT_Geometry__BasicVector3DT_std__complexT_double_t_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_cvector_t_clear" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< std::complex< double > > > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_cvector_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< Geometry::BasicVector3D< std::complex< double > > > *arg1 = (std::vector< Geometry::BasicVector3D< std::complex< double > > > *) 0 ;
@@ -73982,6 +73883,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_cvector_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< Geometry::BasicVector3D< std::complex< double > > > *arg1 = (std::vector< Geometry::BasicVector3D< std::complex< double > > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< Geometry::BasicVector3D< std::complex< double > > > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_cvector_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_std__complexT_double_t_t_std__allocatorT_Geometry__BasicVector3DT_std__complexT_double_t_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_cvector_t_get_allocator" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > > > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< std::complex< double > > > * >(argp1);
+  result = ((std::vector< Geometry::BasicVector3D< std::complex< double > > > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< Geometry::BasicVector3D< std::complex< double > > >::allocator_type(static_cast< const std::vector< Geometry::BasicVector3D< std::complex< double > > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Geometry__BasicVector3DT_std__complexT_double_t_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_cvector_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< Geometry::BasicVector3D< std::complex< double > > > *arg1 = (std::vector< Geometry::BasicVector3D< std::complex< double > > > *) 0 ;
@@ -74074,49 +73997,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_cvector_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< Geometry::BasicVector3D< std::complex< double > > > *arg1 = (std::vector< Geometry::BasicVector3D< std::complex< double > > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_cvector_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_std__complexT_double_t_t_std__allocatorT_Geometry__BasicVector3DT_std__complexT_double_t_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_cvector_t_clear" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< std::complex< double > > > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_cvector_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< Geometry::BasicVector3D< std::complex< double > > > *arg1 = (std::vector< Geometry::BasicVector3D< std::complex< double > > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< Geometry::BasicVector3D< std::complex< double > > > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_cvector_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_Geometry__BasicVector3DT_std__complexT_double_t_t_std__allocatorT_Geometry__BasicVector3DT_std__complexT_double_t_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_cvector_t_get_allocator" "', argument " "1"" of type '" "std::vector< Geometry::BasicVector3D< std::complex< double > > > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< Geometry::BasicVector3D< std::complex< double > > > * >(argp1);
-  result = ((std::vector< Geometry::BasicVector3D< std::complex< double > > > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< Geometry::BasicVector3D< std::complex< double > > >::allocator_type(static_cast< const std::vector< Geometry::BasicVector3D< std::complex< double > > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_Geometry__BasicVector3DT_std__complexT_double_t_t_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vector_cvector_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< Geometry::BasicVector3D< std::complex< double > > >::size_type arg1 ;
@@ -74282,20 +74162,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_cvector_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -74308,7 +74188,7 @@ SWIGINTERN PyObject *_wrap_vector_cvector_t_erase(PyObject *self, PyObject *args
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -74369,14 +74249,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_cvector_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -74395,7 +74275,7 @@ SWIGINTERN PyObject *_wrap_new_vector_cvector_t(PyObject *self, PyObject *args)
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_cvector_t__SWIG_1(self, args);
@@ -74589,20 +74469,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_cvector_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -74616,7 +74496,7 @@ SWIGINTERN PyObject *_wrap_vector_cvector_t_resize(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -74750,20 +74630,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_cvector_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -74780,7 +74660,7 @@ SWIGINTERN PyObject *_wrap_vector_cvector_t_insert(PyObject *self, PyObject *arg
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<Geometry::BasicVector3D< std::complex< double > >,std::allocator< Geometry::BasicVector3D< std::complex< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -75285,14 +75165,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_WavevectorInfo(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -75500,14 +75380,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_Beam(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -75948,14 +75828,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_Bin1D(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -76261,14 +76141,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_Bin1DKVector(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -76589,14 +76469,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_Bin1DCVector(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -77278,7 +77158,7 @@ SWIGINTERN PyObject *_wrap_IAxis_getBinCenters(PyObject *SWIGUNUSEDPARM(self), P
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -77312,7 +77192,7 @@ SWIGINTERN PyObject *_wrap_IAxis_getBinBoundaries(PyObject *SWIGUNUSEDPARM(self)
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -77664,7 +77544,7 @@ SWIGINTERN PyObject *_wrap_new_VariableBinAxis__SWIG_0(PyObject *SWIGUNUSEDPARM(
   } 
   arg3 = static_cast< size_t >(val3);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res4 = swig::asptr(obj3, &ptr);
     if (!SWIG_IsOK(res4)) {
       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VariableBinAxis" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -78014,7 +77894,7 @@ SWIGINTERN PyObject *_wrap_VariableBinAxis_getBinCenters(PyObject *SWIGUNUSEDPAR
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -78048,7 +77928,7 @@ SWIGINTERN PyObject *_wrap_VariableBinAxis_getBinBoundaries(PyObject *SWIGUNUSED
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -78204,14 +78084,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_VariableBinAxis(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -78255,7 +78135,7 @@ SWIGINTERN PyObject *_wrap_new_VariableBinAxis(PyObject *self, PyObject *args) {
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<double,std::allocator< double > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
             return _wrap_new_VariableBinAxis__SWIG_0(self, args);
@@ -78680,14 +78560,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_ConstKBinAxis(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[6] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 5) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -79081,7 +78961,7 @@ SWIGINTERN PyObject *_wrap_CustomBinAxis_getBinCenters(PyObject *SWIGUNUSEDPARM(
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -79438,14 +79318,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IShape2D_contains(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -80180,6 +80060,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< ISample * > *arg1 = (std::vector< ISample * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< ISample * >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:swig_dummy_type_isample_vector_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_p_std__allocatorT_ISample_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_isample_vector_pop" "', argument " "1"" of type '" "std::vector< ISample * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< ISample * > * >(argp1);
+  try {
+    result = (std::vector< ISample * >::value_type)std_vector_Sl_ISample_Sm__Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ISample, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< ISample * > *arg1 = (std::vector< ISample * > *) 0 ;
@@ -80230,6 +80138,70 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< ISample * > *arg1 = (std::vector< ISample * > *) 0 ;
+  std::vector< ISample * >::difference_type arg2 ;
+  std::vector< ISample * >::difference_type arg3 ;
+  std::vector< ISample *,std::allocator< ISample * > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:swig_dummy_type_isample_vector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_p_std__allocatorT_ISample_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_isample_vector___setslice__" "', argument " "1"" of type '" "std::vector< ISample * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< ISample * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "swig_dummy_type_isample_vector___setslice__" "', argument " "2"" of type '" "std::vector< ISample * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector< ISample * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "swig_dummy_type_isample_vector___setslice__" "', argument " "3"" of type '" "std::vector< ISample * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector< ISample * >::difference_type >(val3);
+  {
+    std::vector<ISample*,std::allocator< ISample * > > *ptr = (std::vector<ISample*,std::allocator< ISample * > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "swig_dummy_type_isample_vector___setslice__" "', argument " "4"" of type '" "std::vector< ISample *,std::allocator< ISample * > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "swig_dummy_type_isample_vector___setslice__" "', argument " "4"" of type '" "std::vector< ISample *,std::allocator< ISample * > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  try {
+    std_vector_Sl_ISample_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< ISample *,std::allocator< ISample * > > const &)*arg4);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< ISample * > *arg1 = (std::vector< ISample * > *) 0 ;
   std::vector< ISample * >::difference_type arg2 ;
@@ -80277,85 +80249,21 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< ISample * > *arg1 = (std::vector< ISample * > *) 0 ;
-  std::vector< ISample * >::difference_type arg2 ;
-  std::vector< ISample * >::difference_type arg3 ;
-  std::vector< ISample *,std::allocator< ISample * > > *arg4 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  ptrdiff_t val3 ;
-  int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:swig_dummy_type_isample_vector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_p_std__allocatorT_ISample_p_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_isample_vector___setslice__" "', argument " "1"" of type '" "std::vector< ISample * > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< ISample * > * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "swig_dummy_type_isample_vector___setslice__" "', argument " "2"" of type '" "std::vector< ISample * >::difference_type""'");
-  } 
-  arg2 = static_cast< std::vector< ISample * >::difference_type >(val2);
-  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "swig_dummy_type_isample_vector___setslice__" "', argument " "3"" of type '" "std::vector< ISample * >::difference_type""'");
-  } 
-  arg3 = static_cast< std::vector< ISample * >::difference_type >(val3);
-  {
-    std::vector< ISample*,std::allocator< ISample * > > *ptr = (std::vector< ISample*,std::allocator< ISample * > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "swig_dummy_type_isample_vector___setslice__" "', argument " "4"" of type '" "std::vector< ISample *,std::allocator< ISample * > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "swig_dummy_type_isample_vector___setslice__" "', argument " "4"" of type '" "std::vector< ISample *,std::allocator< ISample * > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
-  try {
-    std_vector_Sl_ISample_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< ISample *,std::allocator< ISample * > > const &)*arg4);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return resultobj;
-fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -80368,14 +80276,14 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___setslice__(PyObject
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_swig_dummy_type_isample_vector___setslice____SWIG_0(self, args);
+          return _wrap_swig_dummy_type_isample_vector___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -80388,10 +80296,10 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___setslice__(PyObject
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_swig_dummy_type_isample_vector___setslice____SWIG_1(self, args);
+            return _wrap_swig_dummy_type_isample_vector___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -80401,8 +80309,8 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___setslice__(PyObject
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'swig_dummy_type_isample_vector___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< ISample * >::__setslice__(std::vector< ISample * >::difference_type,std::vector< ISample * >::difference_type)\n"
-    "    std::vector< ISample * >::__setslice__(std::vector< ISample * >::difference_type,std::vector< ISample * >::difference_type,std::vector< ISample *,std::allocator< ISample * > > const &)\n");
+    "    std::vector< ISample * >::__setslice__(std::vector< ISample * >::difference_type,std::vector< ISample * >::difference_type,std::vector< ISample *,std::allocator< ISample * > > const &)\n"
+    "    std::vector< ISample * >::__setslice__(std::vector< ISample * >::difference_type,std::vector< ISample * >::difference_type)\n");
   return 0;
 }
 
@@ -80483,9 +80391,6 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___delitem____SWIG_0(Py
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -80558,7 +80463,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___setitem____SWIG_0(Py
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< ISample*,std::allocator< ISample * > > *ptr = (std::vector< ISample*,std::allocator< ISample * > > *)0;
+    std::vector<ISample*,std::allocator< ISample * > > *ptr = (std::vector<ISample*,std::allocator< ISample * > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "swig_dummy_type_isample_vector___setitem__" "', argument " "3"" of type '" "std::vector< ISample *,std::allocator< ISample * > > const &""'"); 
@@ -80664,20 +80569,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -80690,7 +80595,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___delitem__(PyObject *
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -80750,20 +80655,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -80776,7 +80681,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___getitem__(PyObject *
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -80844,20 +80749,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -80870,14 +80775,14 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___setitem__(PyObject *
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_swig_dummy_type_isample_vector___setitem____SWIG_0(self, args);
@@ -80887,7 +80792,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector___setitem__(PyObject *
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -80915,34 +80820,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< ISample * > *arg1 = (std::vector< ISample * > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< ISample * >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:swig_dummy_type_isample_vector_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_p_std__allocatorT_ISample_p_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_isample_vector_pop" "', argument " "1"" of type '" "std::vector< ISample * > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< ISample * > * >(argp1);
-  try {
-    result = (std::vector< ISample * >::value_type)std_vector_Sl_ISample_Sm__Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ISample, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< ISample * > *arg1 = (std::vector< ISample * > *) 0 ;
@@ -80995,7 +80872,7 @@ SWIGINTERN PyObject *_wrap_new_swig_dummy_type_isample_vector__SWIG_1(PyObject *
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_swig_dummy_type_isample_vector",&obj0)) SWIG_fail;
   {
-    std::vector< ISample*,std::allocator< ISample * > > *ptr = (std::vector< ISample*,std::allocator< ISample * > > *)0;
+    std::vector<ISample*,std::allocator< ISample * > > *ptr = (std::vector<ISample*,std::allocator< ISample * > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_swig_dummy_type_isample_vector" "', argument " "1"" of type '" "std::vector< ISample * > const &""'"); 
@@ -81059,6 +80936,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< ISample * > *arg1 = (std::vector< ISample * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:swig_dummy_type_isample_vector_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_p_std__allocatorT_ISample_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_isample_vector_clear" "', argument " "1"" of type '" "std::vector< ISample * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< ISample * > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< ISample * > *arg1 = (std::vector< ISample * > *) 0 ;
@@ -81092,6 +80990,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< ISample * > *arg1 = (std::vector< ISample * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< ISample * > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:swig_dummy_type_isample_vector_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_p_std__allocatorT_ISample_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_isample_vector_get_allocator" "', argument " "1"" of type '" "std::vector< ISample * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< ISample * > * >(argp1);
+  result = ((std::vector< ISample * > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< ISample * >::allocator_type(static_cast< const std::vector< ISample * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_ISample_p_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< ISample * > *arg1 = (std::vector< ISample * > *) 0 ;
@@ -81184,49 +81104,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< ISample * > *arg1 = (std::vector< ISample * > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:swig_dummy_type_isample_vector_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_p_std__allocatorT_ISample_p_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_isample_vector_clear" "', argument " "1"" of type '" "std::vector< ISample * > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< ISample * > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< ISample * > *arg1 = (std::vector< ISample * > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< ISample * > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:swig_dummy_type_isample_vector_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_p_std__allocatorT_ISample_p_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_isample_vector_get_allocator" "', argument " "1"" of type '" "std::vector< ISample * > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< ISample * > * >(argp1);
-  result = ((std::vector< ISample * > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< ISample * >::allocator_type(static_cast< const std::vector< ISample * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_ISample_p_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_swig_dummy_type_isample_vector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< ISample * >::size_type arg1 ;
@@ -81392,20 +81269,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -81418,7 +81295,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_erase(PyObject *self,
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -81476,14 +81353,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_swig_dummy_type_isample_vector(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -81502,7 +81379,7 @@ SWIGINTERN PyObject *_wrap_new_swig_dummy_type_isample_vector(PyObject *self, Py
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_swig_dummy_type_isample_vector__SWIG_1(self, args);
@@ -81688,20 +81565,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -81715,7 +81592,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_resize(PyObject *self,
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -81844,20 +81721,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -81875,7 +81752,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_isample_vector_insert(PyObject *self,
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample*,std::allocator< ISample * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample*,std::allocator< ISample * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -82077,6 +81954,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< ISample const * > *arg1 = (std::vector< ISample const * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< ISample const * >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:swig_dummy_type_const_isample_vector_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_const_p_std__allocatorT_ISample_const_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_const_isample_vector_pop" "', argument " "1"" of type '" "std::vector< ISample const * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< ISample const * > * >(argp1);
+  try {
+    result = (std::vector< ISample const * >::value_type)std_vector_Sl_ISample_SS_const_Sm__Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ISample, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< ISample const * > *arg1 = (std::vector< ISample const * > *) 0 ;
@@ -82127,6 +82032,70 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< ISample const * > *arg1 = (std::vector< ISample const * > *) 0 ;
+  std::vector< ISample const * >::difference_type arg2 ;
+  std::vector< ISample const * >::difference_type arg3 ;
+  std::vector< ISample const *,std::allocator< ISample const * > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:swig_dummy_type_const_isample_vector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_const_p_std__allocatorT_ISample_const_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_const_isample_vector___setslice__" "', argument " "1"" of type '" "std::vector< ISample const * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< ISample const * > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "swig_dummy_type_const_isample_vector___setslice__" "', argument " "2"" of type '" "std::vector< ISample const * >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector< ISample const * >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "swig_dummy_type_const_isample_vector___setslice__" "', argument " "3"" of type '" "std::vector< ISample const * >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector< ISample const * >::difference_type >(val3);
+  {
+    std::vector<ISample const*,std::allocator< ISample const * > > *ptr = (std::vector<ISample const*,std::allocator< ISample const * > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "swig_dummy_type_const_isample_vector___setslice__" "', argument " "4"" of type '" "std::vector< ISample const *,std::allocator< ISample const * > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "swig_dummy_type_const_isample_vector___setslice__" "', argument " "4"" of type '" "std::vector< ISample const *,std::allocator< ISample const * > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  try {
+    std_vector_Sl_ISample_SS_const_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< ISample const *,std::allocator< ISample const * > > const &)*arg4);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< ISample const * > *arg1 = (std::vector< ISample const * > *) 0 ;
   std::vector< ISample const * >::difference_type arg2 ;
@@ -82174,85 +82143,21 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< ISample const * > *arg1 = (std::vector< ISample const * > *) 0 ;
-  std::vector< ISample const * >::difference_type arg2 ;
-  std::vector< ISample const * >::difference_type arg3 ;
-  std::vector< ISample const *,std::allocator< ISample const * > > *arg4 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  ptrdiff_t val3 ;
-  int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:swig_dummy_type_const_isample_vector___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_const_p_std__allocatorT_ISample_const_p_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_const_isample_vector___setslice__" "', argument " "1"" of type '" "std::vector< ISample const * > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< ISample const * > * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "swig_dummy_type_const_isample_vector___setslice__" "', argument " "2"" of type '" "std::vector< ISample const * >::difference_type""'");
-  } 
-  arg2 = static_cast< std::vector< ISample const * >::difference_type >(val2);
-  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "swig_dummy_type_const_isample_vector___setslice__" "', argument " "3"" of type '" "std::vector< ISample const * >::difference_type""'");
-  } 
-  arg3 = static_cast< std::vector< ISample const * >::difference_type >(val3);
-  {
-    std::vector< ISample const*,std::allocator< ISample const * > > *ptr = (std::vector< ISample const*,std::allocator< ISample const * > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "swig_dummy_type_const_isample_vector___setslice__" "', argument " "4"" of type '" "std::vector< ISample const *,std::allocator< ISample const * > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "swig_dummy_type_const_isample_vector___setslice__" "', argument " "4"" of type '" "std::vector< ISample const *,std::allocator< ISample const * > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
-  try {
-    std_vector_Sl_ISample_SS_const_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< ISample const *,std::allocator< ISample const * > > const &)*arg4);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return resultobj;
-fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -82265,14 +82170,14 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___setslice__(PyO
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_swig_dummy_type_const_isample_vector___setslice____SWIG_0(self, args);
+          return _wrap_swig_dummy_type_const_isample_vector___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -82285,10 +82190,10 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___setslice__(PyO
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_swig_dummy_type_const_isample_vector___setslice____SWIG_1(self, args);
+            return _wrap_swig_dummy_type_const_isample_vector___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -82298,8 +82203,8 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___setslice__(PyO
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'swig_dummy_type_const_isample_vector___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< ISample const * >::__setslice__(std::vector< ISample const * >::difference_type,std::vector< ISample const * >::difference_type)\n"
-    "    std::vector< ISample const * >::__setslice__(std::vector< ISample const * >::difference_type,std::vector< ISample const * >::difference_type,std::vector< ISample const *,std::allocator< ISample const * > > const &)\n");
+    "    std::vector< ISample const * >::__setslice__(std::vector< ISample const * >::difference_type,std::vector< ISample const * >::difference_type,std::vector< ISample const *,std::allocator< ISample const * > > const &)\n"
+    "    std::vector< ISample const * >::__setslice__(std::vector< ISample const * >::difference_type,std::vector< ISample const * >::difference_type)\n");
   return 0;
 }
 
@@ -82380,9 +82285,6 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___delitem____SWI
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -82455,7 +82357,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___setitem____SWI
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< ISample const*,std::allocator< ISample const * > > *ptr = (std::vector< ISample const*,std::allocator< ISample const * > > *)0;
+    std::vector<ISample const*,std::allocator< ISample const * > > *ptr = (std::vector<ISample const*,std::allocator< ISample const * > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "swig_dummy_type_const_isample_vector___setitem__" "', argument " "3"" of type '" "std::vector< ISample const *,std::allocator< ISample const * > > const &""'"); 
@@ -82561,20 +82463,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -82587,7 +82489,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___delitem__(PyOb
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -82647,20 +82549,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -82673,7 +82575,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___getitem__(PyOb
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -82741,20 +82643,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -82767,14 +82669,14 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___setitem__(PyOb
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_swig_dummy_type_const_isample_vector___setitem____SWIG_0(self, args);
@@ -82784,7 +82686,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector___setitem__(PyOb
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -82812,34 +82714,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< ISample const * > *arg1 = (std::vector< ISample const * > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< ISample const * >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:swig_dummy_type_const_isample_vector_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_const_p_std__allocatorT_ISample_const_p_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_const_isample_vector_pop" "', argument " "1"" of type '" "std::vector< ISample const * > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< ISample const * > * >(argp1);
-  try {
-    result = (std::vector< ISample const * >::value_type)std_vector_Sl_ISample_SS_const_Sm__Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ISample, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< ISample const * > *arg1 = (std::vector< ISample const * > *) 0 ;
@@ -82892,7 +82766,7 @@ SWIGINTERN PyObject *_wrap_new_swig_dummy_type_const_isample_vector__SWIG_1(PyOb
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_swig_dummy_type_const_isample_vector",&obj0)) SWIG_fail;
   {
-    std::vector< ISample const*,std::allocator< ISample const * > > *ptr = (std::vector< ISample const*,std::allocator< ISample const * > > *)0;
+    std::vector<ISample const*,std::allocator< ISample const * > > *ptr = (std::vector<ISample const*,std::allocator< ISample const * > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_swig_dummy_type_const_isample_vector" "', argument " "1"" of type '" "std::vector< ISample const * > const &""'"); 
@@ -82956,6 +82830,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< ISample const * > *arg1 = (std::vector< ISample const * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:swig_dummy_type_const_isample_vector_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_const_p_std__allocatorT_ISample_const_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_const_isample_vector_clear" "', argument " "1"" of type '" "std::vector< ISample const * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< ISample const * > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< ISample const * > *arg1 = (std::vector< ISample const * > *) 0 ;
@@ -82989,6 +82884,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< ISample const * > *arg1 = (std::vector< ISample const * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< ISample const * > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:swig_dummy_type_const_isample_vector_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_const_p_std__allocatorT_ISample_const_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_const_isample_vector_get_allocator" "', argument " "1"" of type '" "std::vector< ISample const * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< ISample const * > * >(argp1);
+  result = ((std::vector< ISample const * > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< ISample const * >::allocator_type(static_cast< const std::vector< ISample const * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_ISample_const_p_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< ISample const * > *arg1 = (std::vector< ISample const * > *) 0 ;
@@ -83081,49 +82998,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< ISample const * > *arg1 = (std::vector< ISample const * > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:swig_dummy_type_const_isample_vector_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_const_p_std__allocatorT_ISample_const_p_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_const_isample_vector_clear" "', argument " "1"" of type '" "std::vector< ISample const * > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< ISample const * > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< ISample const * > *arg1 = (std::vector< ISample const * > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< ISample const * > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:swig_dummy_type_const_isample_vector_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_ISample_const_p_std__allocatorT_ISample_const_p_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "swig_dummy_type_const_isample_vector_get_allocator" "', argument " "1"" of type '" "std::vector< ISample const * > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< ISample const * > * >(argp1);
-  result = ((std::vector< ISample const * > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< ISample const * >::allocator_type(static_cast< const std::vector< ISample const * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_ISample_const_p_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_swig_dummy_type_const_isample_vector__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< ISample const * >::size_type arg1 ;
@@ -83289,20 +83163,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -83315,7 +83189,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_erase(PyObject *
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -83373,14 +83247,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_swig_dummy_type_const_isample_vector(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -83399,7 +83273,7 @@ SWIGINTERN PyObject *_wrap_new_swig_dummy_type_const_isample_vector(PyObject *se
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_swig_dummy_type_const_isample_vector__SWIG_1(self, args);
@@ -83585,20 +83459,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -83612,7 +83486,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_resize(PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -83741,20 +83615,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -83772,7 +83646,7 @@ SWIGINTERN PyObject *_wrap_swig_dummy_type_const_isample_vector_insert(PyObject
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< ISample const*,std::allocator< ISample const * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<ISample const*,std::allocator< ISample const * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -84180,14 +84054,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_ISampleBuilder_registerParameter(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -87299,14 +87173,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_ISampleVisitor_visit(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -88796,7 +88670,7 @@ SWIGINTERN PyObject *_wrap_ICompositeSample_getChildren(PyObject *SWIGUNUSEDPARM
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< ISample const*,std::allocator< ISample const * > > >(result));
+  resultobj = swig::from(static_cast< std::vector<ISample const*,std::allocator< ISample const * > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -88955,14 +88829,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_ICompositeSample_addParametersToExternalPool(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -90530,14 +90404,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IDistribution1D_generateSamples(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -90698,7 +90572,7 @@ SWIGINTERN PyObject *_wrap_IDistribution1D_generateValueList__SWIG_0(PyObject *S
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -90750,7 +90624,7 @@ SWIGINTERN PyObject *_wrap_IDistribution1D_generateValueList__SWIG_1(PyObject *S
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -90758,14 +90632,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IDistribution1D_generateValueList(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -90879,7 +90753,7 @@ SWIGINTERN PyObject *_wrap_IDistribution1D_generateValues(PyObject *SWIGUNUSEDPA
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -91071,14 +90945,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_DistributionGate(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -91360,7 +91234,7 @@ SWIGINTERN PyObject *_wrap_DistributionGate_generateValueList__SWIG_0(PyObject *
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -91412,7 +91286,7 @@ SWIGINTERN PyObject *_wrap_DistributionGate_generateValueList__SWIG_1(PyObject *
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -91420,14 +91294,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_DistributionGate_generateValueList(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -91672,14 +91546,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_DistributionLorentz(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -91939,7 +91813,7 @@ SWIGINTERN PyObject *_wrap_DistributionLorentz_generateValueList__SWIG_0(PyObjec
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -91991,7 +91865,7 @@ SWIGINTERN PyObject *_wrap_DistributionLorentz_generateValueList__SWIG_1(PyObjec
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -91999,14 +91873,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_DistributionLorentz_generateValueList(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -92251,14 +92125,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_DistributionGaussian(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -92518,7 +92392,7 @@ SWIGINTERN PyObject *_wrap_DistributionGaussian_generateValueList__SWIG_0(PyObje
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -92570,7 +92444,7 @@ SWIGINTERN PyObject *_wrap_DistributionGaussian_generateValueList__SWIG_1(PyObje
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -92578,14 +92452,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_DistributionGaussian_generateValueList(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -92839,14 +92713,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_DistributionLogNormal(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -93134,7 +93008,7 @@ SWIGINTERN PyObject *_wrap_DistributionLogNormal_generateValueList__SWIG_0(PyObj
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -93186,7 +93060,7 @@ SWIGINTERN PyObject *_wrap_DistributionLogNormal_generateValueList__SWIG_1(PyObj
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -93194,14 +93068,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_DistributionLogNormal_generateValueList(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -93446,14 +93320,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_DistributionCosine(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -93713,7 +93587,7 @@ SWIGINTERN PyObject *_wrap_DistributionCosine_generateValueList__SWIG_0(PyObject
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -93765,7 +93639,7 @@ SWIGINTERN PyObject *_wrap_DistributionCosine_generateValueList__SWIG_1(PyObject
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -93773,14 +93647,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_DistributionCosine_generateValueList(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -94088,14 +93962,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_Ellipse(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[7] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 6) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -94331,14 +94205,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Ellipse_contains(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -101497,7 +101371,7 @@ SWIGINTERN PyObject *_wrap_FixedBinAxis_getBinCenters(PyObject *SWIGUNUSEDPARM(s
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -101531,7 +101405,7 @@ SWIGINTERN PyObject *_wrap_FixedBinAxis_getBinBoundaries(PyObject *SWIGUNUSEDPAR
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -102316,6 +102190,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< IFormFactor * > *arg1 = (std::vector< IFormFactor * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< IFormFactor * >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_IFormFactorPtr_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_IFormFactorPtr_t_pop" "', argument " "1"" of type '" "std::vector< IFormFactor * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< IFormFactor * > * >(argp1);
+  try {
+    result = (std::vector< IFormFactor * >::value_type)std_vector_Sl_IFormFactor_Sm__Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IFormFactor, 0 |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< IFormFactor * > *arg1 = (std::vector< IFormFactor * > *) 0 ;
@@ -102370,17 +102272,20 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___setslice____SWIG_0(PyObject
   std::vector< IFormFactor * > *arg1 = (std::vector< IFormFactor * > *) 0 ;
   std::vector< IFormFactor * >::difference_type arg2 ;
   std::vector< IFormFactor * >::difference_type arg3 ;
+  std::vector< IFormFactor *,std::allocator< IFormFactor * > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:vector_IFormFactorPtr_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_IFormFactorPtr_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_IFormFactorPtr_t___setslice__" "', argument " "1"" of type '" "std::vector< IFormFactor * > *""'"); 
@@ -102396,8 +102301,19 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___setslice____SWIG_0(PyObject
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_IFormFactorPtr_t___setslice__" "', argument " "3"" of type '" "std::vector< IFormFactor * >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< IFormFactor * >::difference_type >(val3);
+  {
+    std::vector<IFormFactor*,std::allocator< IFormFactor * > > *ptr = (std::vector<IFormFactor*,std::allocator< IFormFactor * > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_IFormFactorPtr_t___setslice__" "', argument " "4"" of type '" "std::vector< IFormFactor *,std::allocator< IFormFactor * > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_IFormFactorPtr_t___setslice__" "', argument " "4"" of type '" "std::vector< IFormFactor *,std::allocator< IFormFactor * > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
   try {
-    std_vector_Sl_IFormFactor_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
+    std_vector_Sl_IFormFactor_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< IFormFactor *,std::allocator< IFormFactor * > > const &)*arg4);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -102407,8 +102323,10 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___setslice____SWIG_0(PyObject
   }
   
   resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
@@ -102418,20 +102336,17 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___setslice____SWIG_1(PyObject
   std::vector< IFormFactor * > *arg1 = (std::vector< IFormFactor * > *) 0 ;
   std::vector< IFormFactor * >::difference_type arg2 ;
   std::vector< IFormFactor * >::difference_type arg3 ;
-  std::vector< IFormFactor *,std::allocator< IFormFactor * > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_IFormFactorPtr_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vector_IFormFactorPtr_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_IFormFactorPtr_t___setslice__" "', argument " "1"" of type '" "std::vector< IFormFactor * > *""'"); 
@@ -102447,19 +102362,8 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___setslice____SWIG_1(PyObject
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_IFormFactorPtr_t___setslice__" "', argument " "3"" of type '" "std::vector< IFormFactor * >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< IFormFactor * >::difference_type >(val3);
-  {
-    std::vector< IFormFactor*,std::allocator< IFormFactor * > > *ptr = (std::vector< IFormFactor*,std::allocator< IFormFactor * > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_IFormFactorPtr_t___setslice__" "', argument " "4"" of type '" "std::vector< IFormFactor *,std::allocator< IFormFactor * > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_IFormFactorPtr_t___setslice__" "', argument " "4"" of type '" "std::vector< IFormFactor *,std::allocator< IFormFactor * > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
   try {
-    std_vector_Sl_IFormFactor_Sm__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< IFormFactor *,std::allocator< IFormFactor * > > const &)*arg4);
+    std_vector_Sl_IFormFactor_Sm__Sg____setslice____SWIG_0(arg1,arg2,arg3);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -102469,29 +102373,27 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___setslice____SWIG_1(PyObject
   }
   
   resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -102504,14 +102406,14 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___setslice__(PyObject *self,
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_IFormFactorPtr_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_IFormFactorPtr_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -102524,10 +102426,10 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___setslice__(PyObject *self,
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_IFormFactorPtr_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_IFormFactorPtr_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -102537,8 +102439,8 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___setslice__(PyObject *self,
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_IFormFactorPtr_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< IFormFactor * >::__setslice__(std::vector< IFormFactor * >::difference_type,std::vector< IFormFactor * >::difference_type)\n"
-    "    std::vector< IFormFactor * >::__setslice__(std::vector< IFormFactor * >::difference_type,std::vector< IFormFactor * >::difference_type,std::vector< IFormFactor *,std::allocator< IFormFactor * > > const &)\n");
+    "    std::vector< IFormFactor * >::__setslice__(std::vector< IFormFactor * >::difference_type,std::vector< IFormFactor * >::difference_type,std::vector< IFormFactor *,std::allocator< IFormFactor * > > const &)\n"
+    "    std::vector< IFormFactor * >::__setslice__(std::vector< IFormFactor * >::difference_type,std::vector< IFormFactor * >::difference_type)\n");
   return 0;
 }
 
@@ -102619,9 +102521,6 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___delitem____SWIG_0(PyObject
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -102694,7 +102593,7 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___setitem____SWIG_0(PyObject
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< IFormFactor*,std::allocator< IFormFactor * > > *ptr = (std::vector< IFormFactor*,std::allocator< IFormFactor * > > *)0;
+    std::vector<IFormFactor*,std::allocator< IFormFactor * > > *ptr = (std::vector<IFormFactor*,std::allocator< IFormFactor * > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_IFormFactorPtr_t___setitem__" "', argument " "3"" of type '" "std::vector< IFormFactor *,std::allocator< IFormFactor * > > const &""'"); 
@@ -102800,20 +102699,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -102826,7 +102725,7 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___delitem__(PyObject *self, P
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -102886,20 +102785,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -102912,7 +102811,7 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___getitem__(PyObject *self, P
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -102980,20 +102879,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -103006,14 +102905,14 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___setitem__(PyObject *self, P
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_IFormFactorPtr_t___setitem____SWIG_0(self, args);
@@ -103023,7 +102922,7 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t___setitem__(PyObject *self, P
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -103051,34 +102950,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< IFormFactor * > *arg1 = (std::vector< IFormFactor * > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< IFormFactor * >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_IFormFactorPtr_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_IFormFactorPtr_t_pop" "', argument " "1"" of type '" "std::vector< IFormFactor * > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< IFormFactor * > * >(argp1);
-  try {
-    result = (std::vector< IFormFactor * >::value_type)std_vector_Sl_IFormFactor_Sm__Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IFormFactor, 0 |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< IFormFactor * > *arg1 = (std::vector< IFormFactor * > *) 0 ;
@@ -103131,7 +103002,7 @@ SWIGINTERN PyObject *_wrap_new_vector_IFormFactorPtr_t__SWIG_1(PyObject *SWIGUNU
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_IFormFactorPtr_t",&obj0)) SWIG_fail;
   {
-    std::vector< IFormFactor*,std::allocator< IFormFactor * > > *ptr = (std::vector< IFormFactor*,std::allocator< IFormFactor * > > *)0;
+    std::vector<IFormFactor*,std::allocator< IFormFactor * > > *ptr = (std::vector<IFormFactor*,std::allocator< IFormFactor * > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_IFormFactorPtr_t" "', argument " "1"" of type '" "std::vector< IFormFactor * > const &""'"); 
@@ -103195,6 +103066,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< IFormFactor * > *arg1 = (std::vector< IFormFactor * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_IFormFactorPtr_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_IFormFactorPtr_t_clear" "', argument " "1"" of type '" "std::vector< IFormFactor * > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< IFormFactor * > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< IFormFactor * > *arg1 = (std::vector< IFormFactor * > *) 0 ;
@@ -103228,6 +103120,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< IFormFactor * > *arg1 = (std::vector< IFormFactor * > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< IFormFactor * > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_IFormFactorPtr_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_IFormFactorPtr_t_get_allocator" "', argument " "1"" of type '" "std::vector< IFormFactor * > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< IFormFactor * > * >(argp1);
+  result = ((std::vector< IFormFactor * > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< IFormFactor * >::allocator_type(static_cast< const std::vector< IFormFactor * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_IFormFactor_p_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< IFormFactor * > *arg1 = (std::vector< IFormFactor * > *) 0 ;
@@ -103320,49 +103234,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< IFormFactor * > *arg1 = (std::vector< IFormFactor * > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_IFormFactorPtr_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_IFormFactorPtr_t_clear" "', argument " "1"" of type '" "std::vector< IFormFactor * > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< IFormFactor * > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< IFormFactor * > *arg1 = (std::vector< IFormFactor * > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< IFormFactor * > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_IFormFactorPtr_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_IFormFactor_p_std__allocatorT_IFormFactor_p_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_IFormFactorPtr_t_get_allocator" "', argument " "1"" of type '" "std::vector< IFormFactor * > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< IFormFactor * > * >(argp1);
-  result = ((std::vector< IFormFactor * > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< IFormFactor * >::allocator_type(static_cast< const std::vector< IFormFactor * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_IFormFactor_p_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vector_IFormFactorPtr_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< IFormFactor * >::size_type arg1 ;
@@ -103528,20 +103399,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -103554,7 +103425,7 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_erase(PyObject *self, PyObjec
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -103612,14 +103483,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_IFormFactorPtr_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -103638,7 +103509,7 @@ SWIGINTERN PyObject *_wrap_new_vector_IFormFactorPtr_t(PyObject *self, PyObject
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_IFormFactorPtr_t__SWIG_1(self, args);
@@ -103824,20 +103695,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -103851,7 +103722,7 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_resize(PyObject *self, PyObje
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -103980,20 +103851,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -104011,7 +103882,7 @@ SWIGINTERN PyObject *_wrap_vector_IFormFactorPtr_t_insert(PyObject *self, PyObje
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< IFormFactor*,std::allocator< IFormFactor * > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<IFormFactor*,std::allocator< IFormFactor * > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -108207,14 +108078,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_FormFactorDecoratorDebyeWaller(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -109906,14 +109777,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_FormFactorGauss(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -111790,14 +111661,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_FormFactorLorentz(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -118036,14 +117907,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FormFactorWeighted_addFormFactor(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -119013,14 +118884,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Simulation_getDetectorIntensity(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -119176,14 +119047,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Simulation_addParametersToExternalPool(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -119477,14 +119348,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Simulation_addParameterDistribution(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[7] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 6) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -119656,14 +119527,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_Simulation(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -120597,14 +120468,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_GISASSimulation_getDetectorIntensity(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -120696,14 +120567,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_GISASSimulation_getIntensityData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -120819,14 +120690,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_GISASSimulation_getInstrument(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -121144,14 +121015,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_GISASSimulation_setDetectorParameters(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[8] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 7) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -121385,14 +121256,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_GISASSimulation_setAnalyzerProperties(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -121547,14 +121418,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_GISASSimulation_addMask(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -121739,14 +121610,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_GISASSimulation_addParametersToExternalPool(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -121838,14 +121709,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_GISASSimulation(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -122350,14 +122221,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_IHistogram(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -122778,14 +122649,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IHistogram_getGlobalBin(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -123071,14 +122942,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IHistogram_getBinContent(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -123278,14 +123149,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IHistogram_getBinError(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -123407,14 +123278,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IHistogram_getBinAverage(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -123536,14 +123407,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IHistogram_getBinNumberOfEntries(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -123787,14 +123658,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IHistogram_getArray(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -123975,14 +123846,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IHistogram_createOutputData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -124346,7 +124217,7 @@ SWIGINTERN PyObject *_wrap_new_Histogram1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self
   } 
   arg2 = static_cast< int >(val2);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Histogram1D" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -124441,14 +124312,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_Histogram1D(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -124483,7 +124354,7 @@ SWIGINTERN PyObject *_wrap_new_Histogram1D(PyObject *self, PyObject *args) {
         _v = SWIG_CheckState(res);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_new_Histogram1D__SWIG_1(self, args);
@@ -124677,14 +124548,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Histogram1D_fill(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -124749,7 +124620,7 @@ SWIGINTERN PyObject *_wrap_Histogram1D_getBinCenters(PyObject *SWIGUNUSEDPARM(se
   }
   arg1 = reinterpret_cast< Histogram1D * >(argp1);
   result = ((Histogram1D const *)arg1)->getBinCenters();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -124771,7 +124642,7 @@ SWIGINTERN PyObject *_wrap_Histogram1D_getBinValues(PyObject *SWIGUNUSEDPARM(sel
   }
   arg1 = reinterpret_cast< Histogram1D * >(argp1);
   result = ((Histogram1D const *)arg1)->getBinValues();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -124793,7 +124664,7 @@ SWIGINTERN PyObject *_wrap_Histogram1D_getBinErrors(PyObject *SWIGUNUSEDPARM(sel
   }
   arg1 = reinterpret_cast< Histogram1D * >(argp1);
   result = ((Histogram1D const *)arg1)->getBinErrors();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -125070,7 +124941,7 @@ SWIGINTERN PyObject *_wrap_new_Histogram2D__SWIG_1(PyObject *SWIGUNUSEDPARM(self
   } 
   arg2 = static_cast< int >(val2);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Histogram2D" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -125086,7 +124957,7 @@ SWIGINTERN PyObject *_wrap_new_Histogram2D__SWIG_1(PyObject *SWIGUNUSEDPARM(self
   } 
   arg4 = static_cast< int >(val4);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res5 = swig::asptr(obj4, &ptr);
     if (!SWIG_IsOK(res5)) {
       SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Histogram2D" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -125195,14 +125066,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_Histogram2D(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[8] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 7) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -125241,7 +125112,7 @@ SWIGINTERN PyObject *_wrap_new_Histogram2D(PyObject *self, PyObject *args) {
         _v = SWIG_CheckState(res);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           {
@@ -125249,7 +125120,7 @@ SWIGINTERN PyObject *_wrap_new_Histogram2D(PyObject *self, PyObject *args) {
             _v = SWIG_CheckState(res);
           }
           if (_v) {
-            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
+            int res = swig::asptr(argv[4], (std::vector<double,std::allocator< double > >**)(0));
             _v = SWIG_CheckState(res);
             if (_v) {
               return _wrap_new_Histogram2D__SWIG_1(self, args);
@@ -125481,14 +125352,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Histogram2D_fill(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -125665,14 +125536,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Histogram2D_projectionX(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -125847,14 +125718,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Histogram2D_projectionY(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -126446,14 +126317,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_HomogeneousMaterial(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -126905,14 +126776,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_HomogeneousMagneticMaterial(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[6] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 5) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -127324,14 +127195,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_IDetector2D(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -127915,14 +127786,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IDetector2D_setAnalyzerProperties(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -128077,14 +127948,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IDetector2D_addMask(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -128366,14 +128237,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IDetector2D_addParametersToExternalPool(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -131223,14 +131094,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IParticle_setPosition(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -133146,14 +133017,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_RotationZ(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -134442,14 +134313,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_Instrument(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -134749,14 +134620,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Instrument_getDetector(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -135161,14 +135032,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Instrument_setAnalyzerProperties(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -135334,14 +135205,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Instrument_getDetectorIntensity(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -135505,14 +135376,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Instrument_addParametersToExternalPool(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -135786,14 +135657,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IntensityDataFunctions_getRelativeDifference(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -136626,14 +136497,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_InterferenceFunctionRadialParaCrystal(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -137314,14 +137185,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_InterferenceFunction2DLattice(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[6] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 5) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -137565,14 +137436,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_InterferenceFunction2DLattice_createSquare(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -137680,14 +137551,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_InterferenceFunction2DLattice_createHexagonal(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -137975,14 +137846,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_InterferenceFunction2DLattice_addParametersToExternalPool(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -138369,14 +138240,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_InterferenceFunction2DParaCrystal(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[7] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 6) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -138761,14 +138632,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_InterferenceFunction2DParaCrystal_createSquare(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -139031,14 +138902,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_InterferenceFunction2DParaCrystal_createHexagonal(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -139305,7 +139176,7 @@ SWIGINTERN PyObject *_wrap_InterferenceFunction2DParaCrystal_getDomainSizes(PyOb
   }
   arg1 = reinterpret_cast< InterferenceFunction2DParaCrystal * >(argp1);
   result = ((InterferenceFunction2DParaCrystal const *)arg1)->getDomainSizes();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -139518,14 +139389,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_InterferenceFunction2DParaCrystal_addParametersToExternalPool(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -140493,14 +140364,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_SphericalDetector(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[8] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 7) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -140758,14 +140629,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SphericalDetector_addParametersToExternalPool(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -141754,14 +141625,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_IsGISAXSDetector(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[8] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 7) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -142303,14 +142174,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_Lattice(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -144064,14 +143935,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_Layer(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -144583,14 +144454,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_LayerRoughness(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -145300,14 +145171,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Line_contains(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -145648,14 +145519,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_VerticalLine_contains(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -146018,14 +145889,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_HorizontalLine_contains(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -146372,14 +146243,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_sinc(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -146555,14 +146426,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Bessel_J0(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -146619,14 +146490,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Bessel_J1(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -146683,14 +146554,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Bessel_J1c(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -146759,7 +146630,7 @@ SWIGINTERN PyObject *_wrap_FastFourierTransform__SWIG_0(PyObject *SWIGUNUSEDPARM
   
   if (!PyArg_ParseTuple(args,(char *)"OO:FastFourierTransform",&obj0,&obj1)) SWIG_fail;
   {
-    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
+    std::vector<std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector<std::complex< double >,std::allocator< std::complex< double > > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FastFourierTransform" "', argument " "1"" of type '" "std::vector< complex_t,std::allocator< complex_t > > const &""'"); 
@@ -146775,7 +146646,7 @@ SWIGINTERN PyObject *_wrap_FastFourierTransform__SWIG_0(PyObject *SWIGUNUSEDPARM
   } 
   arg2 = static_cast< MathFunctions::EFFTDirection >(val2);
   result = MathFunctions::FastFourierTransform((std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)*arg1,arg2);
-  resultobj = swig::from(static_cast< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >(result));
+  resultobj = swig::from(static_cast< std::vector<std::complex< double >,std::allocator< std::complex< double > > > >(result));
   if (SWIG_IsNewObj(res1)) delete arg1;
   return resultobj;
 fail:
@@ -146797,7 +146668,7 @@ SWIGINTERN PyObject *_wrap_FastFourierTransform__SWIG_1(PyObject *SWIGUNUSEDPARM
   
   if (!PyArg_ParseTuple(args,(char *)"OO:FastFourierTransform",&obj0,&obj1)) SWIG_fail;
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FastFourierTransform" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -146813,7 +146684,7 @@ SWIGINTERN PyObject *_wrap_FastFourierTransform__SWIG_1(PyObject *SWIGUNUSEDPARM
   } 
   arg2 = static_cast< MathFunctions::EFFTDirection >(val2);
   result = MathFunctions::FastFourierTransform((std::vector< double,std::allocator< double > > const &)*arg1,arg2);
-  resultobj = swig::from(static_cast< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >(result));
+  resultobj = swig::from(static_cast< std::vector<std::complex< double >,std::allocator< std::complex< double > > > >(result));
   if (SWIG_IsNewObj(res1)) delete arg1;
   return resultobj;
 fail:
@@ -146823,20 +146694,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FastFourierTransform(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -146850,7 +146721,7 @@ SWIGINTERN PyObject *_wrap_FastFourierTransform(PyObject *self, PyObject *args)
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -146884,7 +146755,7 @@ SWIGINTERN PyObject *_wrap_ConvolveFFT(PyObject *SWIGUNUSEDPARM(self), PyObject
   
   if (!PyArg_ParseTuple(args,(char *)"OO:ConvolveFFT",&obj0,&obj1)) SWIG_fail;
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolveFFT" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -146895,7 +146766,7 @@ SWIGINTERN PyObject *_wrap_ConvolveFFT(PyObject *SWIGUNUSEDPARM(self), PyObject
     arg1 = ptr;
   }
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolveFFT" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -146906,7 +146777,7 @@ SWIGINTERN PyObject *_wrap_ConvolveFFT(PyObject *SWIGUNUSEDPARM(self), PyObject
     arg2 = ptr;
   }
   result = MathFunctions::ConvolveFFT((std::vector< double,std::allocator< double > > const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
-  resultobj = swig::from(static_cast< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >(result));
+  resultobj = swig::from(static_cast< std::vector<std::complex< double >,std::allocator< std::complex< double > > > >(result));
   if (SWIG_IsNewObj(res1)) delete arg1;
   if (SWIG_IsNewObj(res2)) delete arg2;
   return resultobj;
@@ -147744,14 +147615,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Logger_SetLevel(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -147853,14 +147724,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SetLevel(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -149231,14 +149102,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_OffSpecSimulation_getDetectorIntensity(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -149590,14 +149461,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_OffSpecSimulation_setDetectorParameters(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[8] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 7) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -149817,14 +149688,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_OffSpecSimulation_setAnalyzerProperties(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -150000,14 +149871,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_OffSpecSimulation_addParametersToExternalPool(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -150099,14 +149970,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_OffSpecSimulation(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -150636,14 +150507,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IntensityData_addAxis(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[6] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 5) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -150785,14 +150656,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IntensityData_getAxis(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -150953,7 +150824,7 @@ SWIGINTERN PyObject *_wrap_IntensityData_getRawDataVector(PyObject *SWIGUNUSEDPA
   }
   arg1 = reinterpret_cast< OutputData< double > * >(argp1);
   result = ((OutputData< double > const *)arg1)->getRawDataVector();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -151057,14 +150928,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IntensityData_begin(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -151141,14 +151012,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IntensityData_end(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -151313,7 +151184,7 @@ SWIGINTERN PyObject *_wrap_IntensityData_getAxesBinIndices(PyObject *SWIGUNUSEDP
   } 
   arg2 = static_cast< size_t >(val2);
   result = ((OutputData< double > const *)arg1)->getAxesBinIndices(arg2);
-  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
+  resultobj = swig::from(static_cast< std::vector<int,std::allocator< int > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -151408,14 +151279,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IntensityData_getAxisBinIndex(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -151487,7 +151358,7 @@ SWIGINTERN PyObject *_wrap_IntensityData_toGlobalIndex(PyObject *SWIGUNUSEDPARM(
   }
   arg1 = reinterpret_cast< OutputData< double > * >(argp1);
   {
-    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
+    std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntensityData_toGlobalIndex" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
@@ -151525,7 +151396,7 @@ SWIGINTERN PyObject *_wrap_IntensityData_findGlobalIndex(PyObject *SWIGUNUSEDPAR
   }
   arg1 = reinterpret_cast< OutputData< double > * >(argp1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntensityData_findGlobalIndex" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -151633,14 +151504,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IntensityData_getAxisValue(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -151718,7 +151589,7 @@ SWIGINTERN PyObject *_wrap_IntensityData_getAxesValues(PyObject *SWIGUNUSEDPARM(
   } 
   arg2 = static_cast< size_t >(val2);
   result = ((OutputData< double > const *)arg1)->getAxesValues(arg2);
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -151813,14 +151684,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IntensityData_getAxisBin(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -152015,7 +151886,7 @@ SWIGINTERN PyObject *_wrap_IntensityData_setRawDataVector(PyObject *SWIGUNUSEDPA
   }
   arg1 = reinterpret_cast< OutputData< double > * >(argp1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntensityData_setRawDataVector" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -152950,14 +152821,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_ParameterDistribution(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[7] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 6) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -153290,7 +153161,7 @@ SWIGINTERN PyObject *_wrap_ParameterDistribution_getLinkedParameterNames(PyObjec
   }
   arg1 = reinterpret_cast< ParameterDistribution * >(argp1);
   result = ((ParameterDistribution const *)arg1)->getLinkedParameterNames();
-  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
+  resultobj = swig::from(static_cast< std::vector<std::string,std::allocator< std::string > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -153810,14 +153681,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_ParameterPool_registerParameter(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -154111,7 +153982,7 @@ SWIGINTERN PyObject *_wrap_ParameterPool_getParameterNames(PyObject *SWIGUNUSEDP
   }
   arg1 = reinterpret_cast< ParameterPool * >(argp1);
   result = ((ParameterPool const *)arg1)->getParameterNames();
-  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
+  resultobj = swig::from(static_cast< std::vector<std::string,std::allocator< std::string > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -154362,14 +154233,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_Particle(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -155179,7 +155050,7 @@ SWIGINTERN PyObject *_wrap_new_ParticleComposition__SWIG_3(PyObject *SWIGUNUSEDP
   }
   arg2 = reinterpret_cast< IParticle * >(argp2);
   {
-    std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *ptr = (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *)0;
+    std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *ptr = (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *)0;
     int res = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res) || !ptr) {
       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParticleComposition" "', argument " "3"" of type '" "std::vector< kvector_t,std::allocator< kvector_t > >""'"); 
@@ -155202,14 +155073,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_ParticleComposition(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -155253,7 +155124,7 @@ SWIGINTERN PyObject *_wrap_new_ParticleComposition(PyObject *self, PyObject *arg
       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_IParticle, 0);
       _v = SWIG_CheckState(res);
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_new_ParticleComposition__SWIG_3(self, args);
@@ -155506,14 +155377,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_ParticleComposition_addParticle(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -155585,7 +155456,7 @@ SWIGINTERN PyObject *_wrap_ParticleComposition_addParticles(PyObject *SWIGUNUSED
   }
   arg2 = reinterpret_cast< IParticle * >(argp2);
   {
-    std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *ptr = (std::vector< Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *)0;
+    std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *ptr = (std::vector<Geometry::BasicVector3D< double >,std::allocator< Geometry::BasicVector3D< double > > > *)0;
     int res = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res) || !ptr) {
       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParticleComposition_addParticles" "', argument " "3"" of type '" "std::vector< kvector_t,std::allocator< kvector_t > >""'"); 
@@ -156468,14 +156339,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_ParticleCoreShell(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -157283,14 +157154,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_ParticleLayout(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -157733,14 +157604,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_ParticleLayout_addParticle(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[6] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 5) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -158288,7 +158159,7 @@ SWIGINTERN PyObject *_wrap_new_Polygon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P
   if (!PyArg_ParseTuple(args,(char *)"OOO:new_Polygon",&obj0,&obj1,&obj2)) SWIG_fail;
   arg1 = obj0;
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     int res = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res) || !ptr) {
       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Polygon" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
@@ -158297,7 +158168,7 @@ SWIGINTERN PyObject *_wrap_new_Polygon__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P
     if (SWIG_IsNewObj(res)) delete ptr;
   }
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     int res = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res) || !ptr) {
       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Polygon" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >""'"); 
@@ -158330,7 +158201,7 @@ SWIGINTERN PyObject *_wrap_new_Polygon__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P
   if (!PyArg_ParseTuple(args,(char *)"OO:new_Polygon",&obj0,&obj1)) SWIG_fail;
   arg1 = obj0;
   {
-    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;
+    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;
     int res = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res) || !ptr) {
       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_Polygon" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >""'"); 
@@ -158353,14 +158224,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_Polygon(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -158368,7 +158239,7 @@ SWIGINTERN PyObject *_wrap_new_Polygon(PyObject *self, PyObject *args) {
     int _v;
     _v = (argv[0] != 0);
     if (_v) {
-      int res = swig::asptr(argv[1], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+      int res = swig::asptr(argv[1], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
       _v = SWIG_CheckState(res);
       if (_v) {
         return _wrap_new_Polygon__SWIG_1(self, args);
@@ -158379,10 +158250,10 @@ SWIGINTERN PyObject *_wrap_new_Polygon(PyObject *self, PyObject *args) {
     int _v;
     _v = (argv[0] != 0);
     if (_v) {
-      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
+      int res = swig::asptr(argv[1], (std::vector<double,std::allocator< double > >**)(0));
       _v = SWIG_CheckState(res);
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_new_Polygon__SWIG_0(self, args);
@@ -158575,14 +158446,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Polygon_contains(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -158866,14 +158737,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_RealParameterWrapper(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -159344,14 +159215,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Rectangle_contains(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -159710,14 +159581,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_RectangularDetector(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[6] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 5) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -159997,14 +159868,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_RectangularDetector_setPosition(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[6] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 5) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -160286,14 +160157,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_RectangularDetector_setPerpendicularToReflectedBeam(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -160528,14 +160399,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_RectangularDetector_addParametersToExternalPool(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -162391,14 +162262,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SpecularSimulation_setBeamParameters(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[6] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 5) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -162546,14 +162417,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SpecularSimulation_setEvanescentWaveAxis(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -162660,7 +162531,7 @@ SWIGINTERN PyObject *_wrap_SpecularSimulation_getScalarR(PyObject *SWIGUNUSEDPAR
   } 
   arg2 = static_cast< size_t >(val2);
   result = ((SpecularSimulation const *)arg1)->getScalarR(arg2);
-  resultobj = swig::from(static_cast< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >(result));
+  resultobj = swig::from(static_cast< std::vector<std::complex< double >,std::allocator< std::complex< double > > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -162691,7 +162562,7 @@ SWIGINTERN PyObject *_wrap_SpecularSimulation_getScalarT(PyObject *SWIGUNUSEDPAR
   } 
   arg2 = static_cast< size_t >(val2);
   result = ((SpecularSimulation const *)arg1)->getScalarT(arg2);
-  resultobj = swig::from(static_cast< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >(result));
+  resultobj = swig::from(static_cast< std::vector<std::complex< double >,std::allocator< std::complex< double > > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -162722,7 +162593,7 @@ SWIGINTERN PyObject *_wrap_SpecularSimulation_getScalarKz(PyObject *SWIGUNUSEDPA
   } 
   arg2 = static_cast< size_t >(val2);
   result = ((SpecularSimulation const *)arg1)->getScalarKz(arg2);
-  resultobj = swig::from(static_cast< std::vector< std::complex< double >,std::allocator< std::complex< double > > > >(result));
+  resultobj = swig::from(static_cast< std::vector<std::complex< double >,std::allocator< std::complex< double > > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -162826,14 +162697,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_SpecularSimulation(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -163294,10 +163165,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vdouble1d_t___nonzero__", _wrap_vdouble1d_t___nonzero__, METH_VARARGS, (char *)"vdouble1d_t___nonzero__(vdouble1d_t self) -> bool"},
 	 { (char *)"vdouble1d_t___bool__", _wrap_vdouble1d_t___bool__, METH_VARARGS, (char *)"vdouble1d_t___bool__(vdouble1d_t self) -> bool"},
 	 { (char *)"vdouble1d_t___len__", _wrap_vdouble1d_t___len__, METH_VARARGS, (char *)"vdouble1d_t___len__(vdouble1d_t self) -> std::vector< double >::size_type"},
+	 { (char *)"vdouble1d_t_pop", _wrap_vdouble1d_t_pop, METH_VARARGS, (char *)"vdouble1d_t_pop(vdouble1d_t self) -> std::vector< double >::value_type"},
 	 { (char *)"vdouble1d_t___getslice__", _wrap_vdouble1d_t___getslice__, METH_VARARGS, (char *)"vdouble1d_t___getslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> vdouble1d_t"},
 	 { (char *)"vdouble1d_t___setslice__", _wrap_vdouble1d_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< double >::difference_type i, std::vector< double >::difference_type j)\n"
-		"vdouble1d_t___setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, vdouble1d_t v)\n"
+		"__setslice__(std::vector< double >::difference_type i, std::vector< double >::difference_type j, vdouble1d_t v)\n"
+		"vdouble1d_t___setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)\n"
 		""},
 	 { (char *)"vdouble1d_t___delslice__", _wrap_vdouble1d_t___delslice__, METH_VARARGS, (char *)"vdouble1d_t___delslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"},
 	 { (char *)"vdouble1d_t___delitem__", _wrap_vdouble1d_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -163313,17 +163185,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vdouble1d_t___setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)\n"
 		""},
-	 { (char *)"vdouble1d_t_pop", _wrap_vdouble1d_t_pop, METH_VARARGS, (char *)"vdouble1d_t_pop(vdouble1d_t self) -> std::vector< double >::value_type"},
 	 { (char *)"vdouble1d_t_append", _wrap_vdouble1d_t_append, METH_VARARGS, (char *)"vdouble1d_t_append(vdouble1d_t self, std::vector< double >::value_type const & x)"},
 	 { (char *)"vdouble1d_t_empty", _wrap_vdouble1d_t_empty, METH_VARARGS, (char *)"vdouble1d_t_empty(vdouble1d_t self) -> bool"},
 	 { (char *)"vdouble1d_t_size", _wrap_vdouble1d_t_size, METH_VARARGS, (char *)"vdouble1d_t_size(vdouble1d_t self) -> std::vector< double >::size_type"},
+	 { (char *)"vdouble1d_t_clear", _wrap_vdouble1d_t_clear, METH_VARARGS, (char *)"vdouble1d_t_clear(vdouble1d_t self)"},
 	 { (char *)"vdouble1d_t_swap", _wrap_vdouble1d_t_swap, METH_VARARGS, (char *)"vdouble1d_t_swap(vdouble1d_t self, vdouble1d_t v)"},
+	 { (char *)"vdouble1d_t_get_allocator", _wrap_vdouble1d_t_get_allocator, METH_VARARGS, (char *)"vdouble1d_t_get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"},
 	 { (char *)"vdouble1d_t_begin", _wrap_vdouble1d_t_begin, METH_VARARGS, (char *)"vdouble1d_t_begin(vdouble1d_t self) -> std::vector< double >::iterator"},
 	 { (char *)"vdouble1d_t_end", _wrap_vdouble1d_t_end, METH_VARARGS, (char *)"vdouble1d_t_end(vdouble1d_t self) -> std::vector< double >::iterator"},
 	 { (char *)"vdouble1d_t_rbegin", _wrap_vdouble1d_t_rbegin, METH_VARARGS, (char *)"vdouble1d_t_rbegin(vdouble1d_t self) -> std::vector< double >::reverse_iterator"},
 	 { (char *)"vdouble1d_t_rend", _wrap_vdouble1d_t_rend, METH_VARARGS, (char *)"vdouble1d_t_rend(vdouble1d_t self) -> std::vector< double >::reverse_iterator"},
-	 { (char *)"vdouble1d_t_clear", _wrap_vdouble1d_t_clear, METH_VARARGS, (char *)"vdouble1d_t_clear(vdouble1d_t self)"},
-	 { (char *)"vdouble1d_t_get_allocator", _wrap_vdouble1d_t_get_allocator, METH_VARARGS, (char *)"vdouble1d_t_get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"},
 	 { (char *)"vdouble1d_t_pop_back", _wrap_vdouble1d_t_pop_back, METH_VARARGS, (char *)"vdouble1d_t_pop_back(vdouble1d_t self)"},
 	 { (char *)"vdouble1d_t_erase", _wrap_vdouble1d_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< double >::iterator pos) -> std::vector< double >::iterator\n"
@@ -163355,10 +163226,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vdouble2d_t___nonzero__", _wrap_vdouble2d_t___nonzero__, METH_VARARGS, (char *)"vdouble2d_t___nonzero__(vdouble2d_t self) -> bool"},
 	 { (char *)"vdouble2d_t___bool__", _wrap_vdouble2d_t___bool__, METH_VARARGS, (char *)"vdouble2d_t___bool__(vdouble2d_t self) -> bool"},
 	 { (char *)"vdouble2d_t___len__", _wrap_vdouble2d_t___len__, METH_VARARGS, (char *)"vdouble2d_t___len__(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"},
+	 { (char *)"vdouble2d_t_pop", _wrap_vdouble2d_t_pop, METH_VARARGS, (char *)"vdouble2d_t_pop(vdouble2d_t self) -> vdouble1d_t"},
 	 { (char *)"vdouble2d_t___getslice__", _wrap_vdouble2d_t___getslice__, METH_VARARGS, (char *)"vdouble2d_t___getslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> vdouble2d_t"},
 	 { (char *)"vdouble2d_t___setslice__", _wrap_vdouble2d_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)\n"
-		"vdouble2d_t___setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, vdouble2d_t v)\n"
+		"__setslice__(std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, vdouble2d_t v)\n"
+		"vdouble2d_t___setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)\n"
 		""},
 	 { (char *)"vdouble2d_t___delslice__", _wrap_vdouble2d_t___delslice__, METH_VARARGS, (char *)"vdouble2d_t___delslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"},
 	 { (char *)"vdouble2d_t___delitem__", _wrap_vdouble2d_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -163374,17 +163246,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vdouble2d_t___setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)\n"
 		""},
-	 { (char *)"vdouble2d_t_pop", _wrap_vdouble2d_t_pop, METH_VARARGS, (char *)"vdouble2d_t_pop(vdouble2d_t self) -> vdouble1d_t"},
 	 { (char *)"vdouble2d_t_append", _wrap_vdouble2d_t_append, METH_VARARGS, (char *)"vdouble2d_t_append(vdouble2d_t self, vdouble1d_t x)"},
 	 { (char *)"vdouble2d_t_empty", _wrap_vdouble2d_t_empty, METH_VARARGS, (char *)"vdouble2d_t_empty(vdouble2d_t self) -> bool"},
 	 { (char *)"vdouble2d_t_size", _wrap_vdouble2d_t_size, METH_VARARGS, (char *)"vdouble2d_t_size(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"},
+	 { (char *)"vdouble2d_t_clear", _wrap_vdouble2d_t_clear, METH_VARARGS, (char *)"vdouble2d_t_clear(vdouble2d_t self)"},
 	 { (char *)"vdouble2d_t_swap", _wrap_vdouble2d_t_swap, METH_VARARGS, (char *)"vdouble2d_t_swap(vdouble2d_t self, vdouble2d_t v)"},
+	 { (char *)"vdouble2d_t_get_allocator", _wrap_vdouble2d_t_get_allocator, METH_VARARGS, (char *)"vdouble2d_t_get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"},
 	 { (char *)"vdouble2d_t_begin", _wrap_vdouble2d_t_begin, METH_VARARGS, (char *)"vdouble2d_t_begin(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"},
 	 { (char *)"vdouble2d_t_end", _wrap_vdouble2d_t_end, METH_VARARGS, (char *)"vdouble2d_t_end(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"},
 	 { (char *)"vdouble2d_t_rbegin", _wrap_vdouble2d_t_rbegin, METH_VARARGS, (char *)"vdouble2d_t_rbegin(vdouble2d_t self) -> std::vector< std::vector< double > >::reverse_iterator"},
 	 { (char *)"vdouble2d_t_rend", _wrap_vdouble2d_t_rend, METH_VARARGS, (char *)"vdouble2d_t_rend(vdouble2d_t self) -> std::vector< std::vector< double > >::reverse_iterator"},
-	 { (char *)"vdouble2d_t_clear", _wrap_vdouble2d_t_clear, METH_VARARGS, (char *)"vdouble2d_t_clear(vdouble2d_t self)"},
-	 { (char *)"vdouble2d_t_get_allocator", _wrap_vdouble2d_t_get_allocator, METH_VARARGS, (char *)"vdouble2d_t_get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"},
 	 { (char *)"vdouble2d_t_pop_back", _wrap_vdouble2d_t_pop_back, METH_VARARGS, (char *)"vdouble2d_t_pop_back(vdouble2d_t self)"},
 	 { (char *)"vdouble2d_t_erase", _wrap_vdouble2d_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< std::vector< double > >::iterator pos) -> std::vector< std::vector< double > >::iterator\n"
@@ -163416,10 +163287,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_integer_t___nonzero__", _wrap_vector_integer_t___nonzero__, METH_VARARGS, (char *)"vector_integer_t___nonzero__(vector_integer_t self) -> bool"},
 	 { (char *)"vector_integer_t___bool__", _wrap_vector_integer_t___bool__, METH_VARARGS, (char *)"vector_integer_t___bool__(vector_integer_t self) -> bool"},
 	 { (char *)"vector_integer_t___len__", _wrap_vector_integer_t___len__, METH_VARARGS, (char *)"vector_integer_t___len__(vector_integer_t self) -> std::vector< int >::size_type"},
+	 { (char *)"vector_integer_t_pop", _wrap_vector_integer_t_pop, METH_VARARGS, (char *)"vector_integer_t_pop(vector_integer_t self) -> std::vector< int >::value_type"},
 	 { (char *)"vector_integer_t___getslice__", _wrap_vector_integer_t___getslice__, METH_VARARGS, (char *)"vector_integer_t___getslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> vector_integer_t"},
 	 { (char *)"vector_integer_t___setslice__", _wrap_vector_integer_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< int >::difference_type i, std::vector< int >::difference_type j)\n"
-		"vector_integer_t___setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, vector_integer_t v)\n"
+		"__setslice__(std::vector< int >::difference_type i, std::vector< int >::difference_type j, vector_integer_t v)\n"
+		"vector_integer_t___setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)\n"
 		""},
 	 { (char *)"vector_integer_t___delslice__", _wrap_vector_integer_t___delslice__, METH_VARARGS, (char *)"vector_integer_t___delslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"},
 	 { (char *)"vector_integer_t___delitem__", _wrap_vector_integer_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -163435,17 +163307,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_integer_t___setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)\n"
 		""},
-	 { (char *)"vector_integer_t_pop", _wrap_vector_integer_t_pop, METH_VARARGS, (char *)"vector_integer_t_pop(vector_integer_t self) -> std::vector< int >::value_type"},
 	 { (char *)"vector_integer_t_append", _wrap_vector_integer_t_append, METH_VARARGS, (char *)"vector_integer_t_append(vector_integer_t self, std::vector< int >::value_type const & x)"},
 	 { (char *)"vector_integer_t_empty", _wrap_vector_integer_t_empty, METH_VARARGS, (char *)"vector_integer_t_empty(vector_integer_t self) -> bool"},
 	 { (char *)"vector_integer_t_size", _wrap_vector_integer_t_size, METH_VARARGS, (char *)"vector_integer_t_size(vector_integer_t self) -> std::vector< int >::size_type"},
+	 { (char *)"vector_integer_t_clear", _wrap_vector_integer_t_clear, METH_VARARGS, (char *)"vector_integer_t_clear(vector_integer_t self)"},
 	 { (char *)"vector_integer_t_swap", _wrap_vector_integer_t_swap, METH_VARARGS, (char *)"vector_integer_t_swap(vector_integer_t self, vector_integer_t v)"},
+	 { (char *)"vector_integer_t_get_allocator", _wrap_vector_integer_t_get_allocator, METH_VARARGS, (char *)"vector_integer_t_get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"},
 	 { (char *)"vector_integer_t_begin", _wrap_vector_integer_t_begin, METH_VARARGS, (char *)"vector_integer_t_begin(vector_integer_t self) -> std::vector< int >::iterator"},
 	 { (char *)"vector_integer_t_end", _wrap_vector_integer_t_end, METH_VARARGS, (char *)"vector_integer_t_end(vector_integer_t self) -> std::vector< int >::iterator"},
 	 { (char *)"vector_integer_t_rbegin", _wrap_vector_integer_t_rbegin, METH_VARARGS, (char *)"vector_integer_t_rbegin(vector_integer_t self) -> std::vector< int >::reverse_iterator"},
 	 { (char *)"vector_integer_t_rend", _wrap_vector_integer_t_rend, METH_VARARGS, (char *)"vector_integer_t_rend(vector_integer_t self) -> std::vector< int >::reverse_iterator"},
-	 { (char *)"vector_integer_t_clear", _wrap_vector_integer_t_clear, METH_VARARGS, (char *)"vector_integer_t_clear(vector_integer_t self)"},
-	 { (char *)"vector_integer_t_get_allocator", _wrap_vector_integer_t_get_allocator, METH_VARARGS, (char *)"vector_integer_t_get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"},
 	 { (char *)"vector_integer_t_pop_back", _wrap_vector_integer_t_pop_back, METH_VARARGS, (char *)"vector_integer_t_pop_back(vector_integer_t self)"},
 	 { (char *)"vector_integer_t_erase", _wrap_vector_integer_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< int >::iterator pos) -> std::vector< int >::iterator\n"
@@ -163477,10 +163348,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_longinteger_t___nonzero__", _wrap_vector_longinteger_t___nonzero__, METH_VARARGS, (char *)"vector_longinteger_t___nonzero__(vector_longinteger_t self) -> bool"},
 	 { (char *)"vector_longinteger_t___bool__", _wrap_vector_longinteger_t___bool__, METH_VARARGS, (char *)"vector_longinteger_t___bool__(vector_longinteger_t self) -> bool"},
 	 { (char *)"vector_longinteger_t___len__", _wrap_vector_longinteger_t___len__, METH_VARARGS, (char *)"vector_longinteger_t___len__(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"},
+	 { (char *)"vector_longinteger_t_pop", _wrap_vector_longinteger_t_pop, METH_VARARGS, (char *)"vector_longinteger_t_pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"},
 	 { (char *)"vector_longinteger_t___getslice__", _wrap_vector_longinteger_t___getslice__, METH_VARARGS, (char *)"vector_longinteger_t___getslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j) -> vector_longinteger_t"},
 	 { (char *)"vector_longinteger_t___setslice__", _wrap_vector_longinteger_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)\n"
-		"vector_longinteger_t___setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, vector_longinteger_t v)\n"
+		"__setslice__(std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, vector_longinteger_t v)\n"
+		"vector_longinteger_t___setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)\n"
 		""},
 	 { (char *)"vector_longinteger_t___delslice__", _wrap_vector_longinteger_t___delslice__, METH_VARARGS, (char *)"vector_longinteger_t___delslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"},
 	 { (char *)"vector_longinteger_t___delitem__", _wrap_vector_longinteger_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -163496,17 +163368,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_longinteger_t___setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)\n"
 		""},
-	 { (char *)"vector_longinteger_t_pop", _wrap_vector_longinteger_t_pop, METH_VARARGS, (char *)"vector_longinteger_t_pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"},
 	 { (char *)"vector_longinteger_t_append", _wrap_vector_longinteger_t_append, METH_VARARGS, (char *)"vector_longinteger_t_append(vector_longinteger_t self, std::vector< unsigned long >::value_type const & x)"},
 	 { (char *)"vector_longinteger_t_empty", _wrap_vector_longinteger_t_empty, METH_VARARGS, (char *)"vector_longinteger_t_empty(vector_longinteger_t self) -> bool"},
 	 { (char *)"vector_longinteger_t_size", _wrap_vector_longinteger_t_size, METH_VARARGS, (char *)"vector_longinteger_t_size(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"},
+	 { (char *)"vector_longinteger_t_clear", _wrap_vector_longinteger_t_clear, METH_VARARGS, (char *)"vector_longinteger_t_clear(vector_longinteger_t self)"},
 	 { (char *)"vector_longinteger_t_swap", _wrap_vector_longinteger_t_swap, METH_VARARGS, (char *)"vector_longinteger_t_swap(vector_longinteger_t self, vector_longinteger_t v)"},
+	 { (char *)"vector_longinteger_t_get_allocator", _wrap_vector_longinteger_t_get_allocator, METH_VARARGS, (char *)"vector_longinteger_t_get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"},
 	 { (char *)"vector_longinteger_t_begin", _wrap_vector_longinteger_t_begin, METH_VARARGS, (char *)"vector_longinteger_t_begin(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"},
 	 { (char *)"vector_longinteger_t_end", _wrap_vector_longinteger_t_end, METH_VARARGS, (char *)"vector_longinteger_t_end(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"},
 	 { (char *)"vector_longinteger_t_rbegin", _wrap_vector_longinteger_t_rbegin, METH_VARARGS, (char *)"vector_longinteger_t_rbegin(vector_longinteger_t self) -> std::vector< unsigned long >::reverse_iterator"},
 	 { (char *)"vector_longinteger_t_rend", _wrap_vector_longinteger_t_rend, METH_VARARGS, (char *)"vector_longinteger_t_rend(vector_longinteger_t self) -> std::vector< unsigned long >::reverse_iterator"},
-	 { (char *)"vector_longinteger_t_clear", _wrap_vector_longinteger_t_clear, METH_VARARGS, (char *)"vector_longinteger_t_clear(vector_longinteger_t self)"},
-	 { (char *)"vector_longinteger_t_get_allocator", _wrap_vector_longinteger_t_get_allocator, METH_VARARGS, (char *)"vector_longinteger_t_get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"},
 	 { (char *)"vector_longinteger_t_pop_back", _wrap_vector_longinteger_t_pop_back, METH_VARARGS, (char *)"vector_longinteger_t_pop_back(vector_longinteger_t self)"},
 	 { (char *)"vector_longinteger_t_erase", _wrap_vector_longinteger_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< unsigned long >::iterator pos) -> std::vector< unsigned long >::iterator\n"
@@ -163538,10 +163409,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_complex_t___nonzero__", _wrap_vector_complex_t___nonzero__, METH_VARARGS, (char *)"vector_complex_t___nonzero__(vector_complex_t self) -> bool"},
 	 { (char *)"vector_complex_t___bool__", _wrap_vector_complex_t___bool__, METH_VARARGS, (char *)"vector_complex_t___bool__(vector_complex_t self) -> bool"},
 	 { (char *)"vector_complex_t___len__", _wrap_vector_complex_t___len__, METH_VARARGS, (char *)"vector_complex_t___len__(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"},
+	 { (char *)"vector_complex_t_pop", _wrap_vector_complex_t_pop, METH_VARARGS, (char *)"vector_complex_t_pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"},
 	 { (char *)"vector_complex_t___getslice__", _wrap_vector_complex_t___getslice__, METH_VARARGS, (char *)"vector_complex_t___getslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j) -> vector_complex_t"},
 	 { (char *)"vector_complex_t___setslice__", _wrap_vector_complex_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)\n"
-		"vector_complex_t___setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, vector_complex_t v)\n"
+		"__setslice__(std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, vector_complex_t v)\n"
+		"vector_complex_t___setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)\n"
 		""},
 	 { (char *)"vector_complex_t___delslice__", _wrap_vector_complex_t___delslice__, METH_VARARGS, (char *)"vector_complex_t___delslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"},
 	 { (char *)"vector_complex_t___delitem__", _wrap_vector_complex_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -163557,17 +163429,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_complex_t___setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)\n"
 		""},
-	 { (char *)"vector_complex_t_pop", _wrap_vector_complex_t_pop, METH_VARARGS, (char *)"vector_complex_t_pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"},
 	 { (char *)"vector_complex_t_append", _wrap_vector_complex_t_append, METH_VARARGS, (char *)"vector_complex_t_append(vector_complex_t self, std::vector< std::complex< double > >::value_type const & x)"},
 	 { (char *)"vector_complex_t_empty", _wrap_vector_complex_t_empty, METH_VARARGS, (char *)"vector_complex_t_empty(vector_complex_t self) -> bool"},
 	 { (char *)"vector_complex_t_size", _wrap_vector_complex_t_size, METH_VARARGS, (char *)"vector_complex_t_size(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"},
+	 { (char *)"vector_complex_t_clear", _wrap_vector_complex_t_clear, METH_VARARGS, (char *)"vector_complex_t_clear(vector_complex_t self)"},
 	 { (char *)"vector_complex_t_swap", _wrap_vector_complex_t_swap, METH_VARARGS, (char *)"vector_complex_t_swap(vector_complex_t self, vector_complex_t v)"},
+	 { (char *)"vector_complex_t_get_allocator", _wrap_vector_complex_t_get_allocator, METH_VARARGS, (char *)"vector_complex_t_get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"},
 	 { (char *)"vector_complex_t_begin", _wrap_vector_complex_t_begin, METH_VARARGS, (char *)"vector_complex_t_begin(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"},
 	 { (char *)"vector_complex_t_end", _wrap_vector_complex_t_end, METH_VARARGS, (char *)"vector_complex_t_end(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"},
 	 { (char *)"vector_complex_t_rbegin", _wrap_vector_complex_t_rbegin, METH_VARARGS, (char *)"vector_complex_t_rbegin(vector_complex_t self) -> std::vector< std::complex< double > >::reverse_iterator"},
 	 { (char *)"vector_complex_t_rend", _wrap_vector_complex_t_rend, METH_VARARGS, (char *)"vector_complex_t_rend(vector_complex_t self) -> std::vector< std::complex< double > >::reverse_iterator"},
-	 { (char *)"vector_complex_t_clear", _wrap_vector_complex_t_clear, METH_VARARGS, (char *)"vector_complex_t_clear(vector_complex_t self)"},
-	 { (char *)"vector_complex_t_get_allocator", _wrap_vector_complex_t_get_allocator, METH_VARARGS, (char *)"vector_complex_t_get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"},
 	 { (char *)"vector_complex_t_pop_back", _wrap_vector_complex_t_pop_back, METH_VARARGS, (char *)"vector_complex_t_pop_back(vector_complex_t self)"},
 	 { (char *)"vector_complex_t_erase", _wrap_vector_complex_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< std::complex< double > >::iterator pos) -> std::vector< std::complex< double > >::iterator\n"
@@ -163599,10 +163470,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_string_t___nonzero__", _wrap_vector_string_t___nonzero__, METH_VARARGS, (char *)"vector_string_t___nonzero__(vector_string_t self) -> bool"},
 	 { (char *)"vector_string_t___bool__", _wrap_vector_string_t___bool__, METH_VARARGS, (char *)"vector_string_t___bool__(vector_string_t self) -> bool"},
 	 { (char *)"vector_string_t___len__", _wrap_vector_string_t___len__, METH_VARARGS, (char *)"vector_string_t___len__(vector_string_t self) -> std::vector< std::string >::size_type"},
+	 { (char *)"vector_string_t_pop", _wrap_vector_string_t_pop, METH_VARARGS, (char *)"vector_string_t_pop(vector_string_t self) -> std::vector< std::string >::value_type"},
 	 { (char *)"vector_string_t___getslice__", _wrap_vector_string_t___getslice__, METH_VARARGS, (char *)"vector_string_t___getslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> vector_string_t"},
 	 { (char *)"vector_string_t___setslice__", _wrap_vector_string_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)\n"
-		"vector_string_t___setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, vector_string_t v)\n"
+		"__setslice__(std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, vector_string_t v)\n"
+		"vector_string_t___setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)\n"
 		""},
 	 { (char *)"vector_string_t___delslice__", _wrap_vector_string_t___delslice__, METH_VARARGS, (char *)"vector_string_t___delslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"},
 	 { (char *)"vector_string_t___delitem__", _wrap_vector_string_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -163618,17 +163490,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_string_t___setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)\n"
 		""},
-	 { (char *)"vector_string_t_pop", _wrap_vector_string_t_pop, METH_VARARGS, (char *)"vector_string_t_pop(vector_string_t self) -> std::vector< std::string >::value_type"},
 	 { (char *)"vector_string_t_append", _wrap_vector_string_t_append, METH_VARARGS, (char *)"vector_string_t_append(vector_string_t self, std::vector< std::string >::value_type const & x)"},
 	 { (char *)"vector_string_t_empty", _wrap_vector_string_t_empty, METH_VARARGS, (char *)"vector_string_t_empty(vector_string_t self) -> bool"},
 	 { (char *)"vector_string_t_size", _wrap_vector_string_t_size, METH_VARARGS, (char *)"vector_string_t_size(vector_string_t self) -> std::vector< std::string >::size_type"},
+	 { (char *)"vector_string_t_clear", _wrap_vector_string_t_clear, METH_VARARGS, (char *)"vector_string_t_clear(vector_string_t self)"},
 	 { (char *)"vector_string_t_swap", _wrap_vector_string_t_swap, METH_VARARGS, (char *)"vector_string_t_swap(vector_string_t self, vector_string_t v)"},
+	 { (char *)"vector_string_t_get_allocator", _wrap_vector_string_t_get_allocator, METH_VARARGS, (char *)"vector_string_t_get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"},
 	 { (char *)"vector_string_t_begin", _wrap_vector_string_t_begin, METH_VARARGS, (char *)"vector_string_t_begin(vector_string_t self) -> std::vector< std::string >::iterator"},
 	 { (char *)"vector_string_t_end", _wrap_vector_string_t_end, METH_VARARGS, (char *)"vector_string_t_end(vector_string_t self) -> std::vector< std::string >::iterator"},
 	 { (char *)"vector_string_t_rbegin", _wrap_vector_string_t_rbegin, METH_VARARGS, (char *)"vector_string_t_rbegin(vector_string_t self) -> std::vector< std::string >::reverse_iterator"},
 	 { (char *)"vector_string_t_rend", _wrap_vector_string_t_rend, METH_VARARGS, (char *)"vector_string_t_rend(vector_string_t self) -> std::vector< std::string >::reverse_iterator"},
-	 { (char *)"vector_string_t_clear", _wrap_vector_string_t_clear, METH_VARARGS, (char *)"vector_string_t_clear(vector_string_t self)"},
-	 { (char *)"vector_string_t_get_allocator", _wrap_vector_string_t_get_allocator, METH_VARARGS, (char *)"vector_string_t_get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"},
 	 { (char *)"vector_string_t_pop_back", _wrap_vector_string_t_pop_back, METH_VARARGS, (char *)"vector_string_t_pop_back(vector_string_t self)"},
 	 { (char *)"vector_string_t_erase", _wrap_vector_string_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator\n"
@@ -164291,10 +164162,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_kvector_t___nonzero__", _wrap_vector_kvector_t___nonzero__, METH_VARARGS, (char *)"vector_kvector_t___nonzero__(vector_kvector_t self) -> bool"},
 	 { (char *)"vector_kvector_t___bool__", _wrap_vector_kvector_t___bool__, METH_VARARGS, (char *)"vector_kvector_t___bool__(vector_kvector_t self) -> bool"},
 	 { (char *)"vector_kvector_t___len__", _wrap_vector_kvector_t___len__, METH_VARARGS, (char *)"vector_kvector_t___len__(vector_kvector_t self) -> std::vector< Geometry::BasicVector3D< double > >::size_type"},
+	 { (char *)"vector_kvector_t_pop", _wrap_vector_kvector_t_pop, METH_VARARGS, (char *)"vector_kvector_t_pop(vector_kvector_t self) -> kvector_t"},
 	 { (char *)"vector_kvector_t___getslice__", _wrap_vector_kvector_t___getslice__, METH_VARARGS, (char *)"vector_kvector_t___getslice__(vector_kvector_t self, std::vector< Geometry::BasicVector3D< double > >::difference_type i, std::vector< Geometry::BasicVector3D< double > >::difference_type j) -> vector_kvector_t"},
 	 { (char *)"vector_kvector_t___setslice__", _wrap_vector_kvector_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< Geometry::BasicVector3D< double > >::difference_type i, std::vector< Geometry::BasicVector3D< double > >::difference_type j)\n"
-		"vector_kvector_t___setslice__(vector_kvector_t self, std::vector< Geometry::BasicVector3D< double > >::difference_type i, std::vector< Geometry::BasicVector3D< double > >::difference_type j, vector_kvector_t v)\n"
+		"__setslice__(std::vector< Geometry::BasicVector3D< double > >::difference_type i, std::vector< Geometry::BasicVector3D< double > >::difference_type j, vector_kvector_t v)\n"
+		"vector_kvector_t___setslice__(vector_kvector_t self, std::vector< Geometry::BasicVector3D< double > >::difference_type i, std::vector< Geometry::BasicVector3D< double > >::difference_type j)\n"
 		""},
 	 { (char *)"vector_kvector_t___delslice__", _wrap_vector_kvector_t___delslice__, METH_VARARGS, (char *)"vector_kvector_t___delslice__(vector_kvector_t self, std::vector< Geometry::BasicVector3D< double > >::difference_type i, std::vector< Geometry::BasicVector3D< double > >::difference_type j)"},
 	 { (char *)"vector_kvector_t___delitem__", _wrap_vector_kvector_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -164310,17 +164182,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_kvector_t___setitem__(vector_kvector_t self, std::vector< Geometry::BasicVector3D< double > >::difference_type i, kvector_t x)\n"
 		""},
-	 { (char *)"vector_kvector_t_pop", _wrap_vector_kvector_t_pop, METH_VARARGS, (char *)"vector_kvector_t_pop(vector_kvector_t self) -> kvector_t"},
 	 { (char *)"vector_kvector_t_append", _wrap_vector_kvector_t_append, METH_VARARGS, (char *)"vector_kvector_t_append(vector_kvector_t self, kvector_t x)"},
 	 { (char *)"vector_kvector_t_empty", _wrap_vector_kvector_t_empty, METH_VARARGS, (char *)"vector_kvector_t_empty(vector_kvector_t self) -> bool"},
 	 { (char *)"vector_kvector_t_size", _wrap_vector_kvector_t_size, METH_VARARGS, (char *)"vector_kvector_t_size(vector_kvector_t self) -> std::vector< Geometry::BasicVector3D< double > >::size_type"},
+	 { (char *)"vector_kvector_t_clear", _wrap_vector_kvector_t_clear, METH_VARARGS, (char *)"vector_kvector_t_clear(vector_kvector_t self)"},
 	 { (char *)"vector_kvector_t_swap", _wrap_vector_kvector_t_swap, METH_VARARGS, (char *)"vector_kvector_t_swap(vector_kvector_t self, vector_kvector_t v)"},
+	 { (char *)"vector_kvector_t_get_allocator", _wrap_vector_kvector_t_get_allocator, METH_VARARGS, (char *)"vector_kvector_t_get_allocator(vector_kvector_t self) -> std::vector< Geometry::BasicVector3D< double > >::allocator_type"},
 	 { (char *)"vector_kvector_t_begin", _wrap_vector_kvector_t_begin, METH_VARARGS, (char *)"vector_kvector_t_begin(vector_kvector_t self) -> std::vector< Geometry::BasicVector3D< double > >::iterator"},
 	 { (char *)"vector_kvector_t_end", _wrap_vector_kvector_t_end, METH_VARARGS, (char *)"vector_kvector_t_end(vector_kvector_t self) -> std::vector< Geometry::BasicVector3D< double > >::iterator"},
 	 { (char *)"vector_kvector_t_rbegin", _wrap_vector_kvector_t_rbegin, METH_VARARGS, (char *)"vector_kvector_t_rbegin(vector_kvector_t self) -> std::vector< Geometry::BasicVector3D< double > >::reverse_iterator"},
 	 { (char *)"vector_kvector_t_rend", _wrap_vector_kvector_t_rend, METH_VARARGS, (char *)"vector_kvector_t_rend(vector_kvector_t self) -> std::vector< Geometry::BasicVector3D< double > >::reverse_iterator"},
-	 { (char *)"vector_kvector_t_clear", _wrap_vector_kvector_t_clear, METH_VARARGS, (char *)"vector_kvector_t_clear(vector_kvector_t self)"},
-	 { (char *)"vector_kvector_t_get_allocator", _wrap_vector_kvector_t_get_allocator, METH_VARARGS, (char *)"vector_kvector_t_get_allocator(vector_kvector_t self) -> std::vector< Geometry::BasicVector3D< double > >::allocator_type"},
 	 { (char *)"vector_kvector_t_pop_back", _wrap_vector_kvector_t_pop_back, METH_VARARGS, (char *)"vector_kvector_t_pop_back(vector_kvector_t self)"},
 	 { (char *)"vector_kvector_t_erase", _wrap_vector_kvector_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< Geometry::BasicVector3D< double > >::iterator pos) -> std::vector< Geometry::BasicVector3D< double > >::iterator\n"
@@ -164485,10 +164356,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_cvector_t___nonzero__", _wrap_vector_cvector_t___nonzero__, METH_VARARGS, (char *)"vector_cvector_t___nonzero__(vector_cvector_t self) -> bool"},
 	 { (char *)"vector_cvector_t___bool__", _wrap_vector_cvector_t___bool__, METH_VARARGS, (char *)"vector_cvector_t___bool__(vector_cvector_t self) -> bool"},
 	 { (char *)"vector_cvector_t___len__", _wrap_vector_cvector_t___len__, METH_VARARGS, (char *)"vector_cvector_t___len__(vector_cvector_t self) -> std::vector< Geometry::BasicVector3D< std::complex< double > > >::size_type"},
+	 { (char *)"vector_cvector_t_pop", _wrap_vector_cvector_t_pop, METH_VARARGS, (char *)"vector_cvector_t_pop(vector_cvector_t self) -> cvector_t"},
 	 { (char *)"vector_cvector_t___getslice__", _wrap_vector_cvector_t___getslice__, METH_VARARGS, (char *)"vector_cvector_t___getslice__(vector_cvector_t self, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j) -> vector_cvector_t"},
 	 { (char *)"vector_cvector_t___setslice__", _wrap_vector_cvector_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j)\n"
-		"vector_cvector_t___setslice__(vector_cvector_t self, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j, vector_cvector_t v)\n"
+		"__setslice__(std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j, vector_cvector_t v)\n"
+		"vector_cvector_t___setslice__(vector_cvector_t self, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j)\n"
 		""},
 	 { (char *)"vector_cvector_t___delslice__", _wrap_vector_cvector_t___delslice__, METH_VARARGS, (char *)"vector_cvector_t___delslice__(vector_cvector_t self, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type j)"},
 	 { (char *)"vector_cvector_t___delitem__", _wrap_vector_cvector_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -164504,17 +164376,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_cvector_t___setitem__(vector_cvector_t self, std::vector< Geometry::BasicVector3D< std::complex< double > > >::difference_type i, cvector_t x)\n"
 		""},
-	 { (char *)"vector_cvector_t_pop", _wrap_vector_cvector_t_pop, METH_VARARGS, (char *)"vector_cvector_t_pop(vector_cvector_t self) -> cvector_t"},
 	 { (char *)"vector_cvector_t_append", _wrap_vector_cvector_t_append, METH_VARARGS, (char *)"vector_cvector_t_append(vector_cvector_t self, cvector_t x)"},
 	 { (char *)"vector_cvector_t_empty", _wrap_vector_cvector_t_empty, METH_VARARGS, (char *)"vector_cvector_t_empty(vector_cvector_t self) -> bool"},
 	 { (char *)"vector_cvector_t_size", _wrap_vector_cvector_t_size, METH_VARARGS, (char *)"vector_cvector_t_size(vector_cvector_t self) -> std::vector< Geometry::BasicVector3D< std::complex< double > > >::size_type"},
+	 { (char *)"vector_cvector_t_clear", _wrap_vector_cvector_t_clear, METH_VARARGS, (char *)"vector_cvector_t_clear(vector_cvector_t self)"},
 	 { (char *)"vector_cvector_t_swap", _wrap_vector_cvector_t_swap, METH_VARARGS, (char *)"vector_cvector_t_swap(vector_cvector_t self, vector_cvector_t v)"},
+	 { (char *)"vector_cvector_t_get_allocator", _wrap_vector_cvector_t_get_allocator, METH_VARARGS, (char *)"vector_cvector_t_get_allocator(vector_cvector_t self) -> std::vector< Geometry::BasicVector3D< std::complex< double > > >::allocator_type"},
 	 { (char *)"vector_cvector_t_begin", _wrap_vector_cvector_t_begin, METH_VARARGS, (char *)"vector_cvector_t_begin(vector_cvector_t self) -> std::vector< Geometry::BasicVector3D< std::complex< double > > >::iterator"},
 	 { (char *)"vector_cvector_t_end", _wrap_vector_cvector_t_end, METH_VARARGS, (char *)"vector_cvector_t_end(vector_cvector_t self) -> std::vector< Geometry::BasicVector3D< std::complex< double > > >::iterator"},
 	 { (char *)"vector_cvector_t_rbegin", _wrap_vector_cvector_t_rbegin, METH_VARARGS, (char *)"vector_cvector_t_rbegin(vector_cvector_t self) -> std::vector< Geometry::BasicVector3D< std::complex< double > > >::reverse_iterator"},
 	 { (char *)"vector_cvector_t_rend", _wrap_vector_cvector_t_rend, METH_VARARGS, (char *)"vector_cvector_t_rend(vector_cvector_t self) -> std::vector< Geometry::BasicVector3D< std::complex< double > > >::reverse_iterator"},
-	 { (char *)"vector_cvector_t_clear", _wrap_vector_cvector_t_clear, METH_VARARGS, (char *)"vector_cvector_t_clear(vector_cvector_t self)"},
-	 { (char *)"vector_cvector_t_get_allocator", _wrap_vector_cvector_t_get_allocator, METH_VARARGS, (char *)"vector_cvector_t_get_allocator(vector_cvector_t self) -> std::vector< Geometry::BasicVector3D< std::complex< double > > >::allocator_type"},
 	 { (char *)"vector_cvector_t_pop_back", _wrap_vector_cvector_t_pop_back, METH_VARARGS, (char *)"vector_cvector_t_pop_back(vector_cvector_t self)"},
 	 { (char *)"vector_cvector_t_erase", _wrap_vector_cvector_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< Geometry::BasicVector3D< std::complex< double > > >::iterator pos) -> std::vector< Geometry::BasicVector3D< std::complex< double > > >::iterator\n"
@@ -165201,10 +165072,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"swig_dummy_type_isample_vector___nonzero__", _wrap_swig_dummy_type_isample_vector___nonzero__, METH_VARARGS, (char *)"swig_dummy_type_isample_vector___nonzero__(swig_dummy_type_isample_vector self) -> bool"},
 	 { (char *)"swig_dummy_type_isample_vector___bool__", _wrap_swig_dummy_type_isample_vector___bool__, METH_VARARGS, (char *)"swig_dummy_type_isample_vector___bool__(swig_dummy_type_isample_vector self) -> bool"},
 	 { (char *)"swig_dummy_type_isample_vector___len__", _wrap_swig_dummy_type_isample_vector___len__, METH_VARARGS, (char *)"swig_dummy_type_isample_vector___len__(swig_dummy_type_isample_vector self) -> std::vector< ISample * >::size_type"},
+	 { (char *)"swig_dummy_type_isample_vector_pop", _wrap_swig_dummy_type_isample_vector_pop, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_pop(swig_dummy_type_isample_vector self) -> ISample"},
 	 { (char *)"swig_dummy_type_isample_vector___getslice__", _wrap_swig_dummy_type_isample_vector___getslice__, METH_VARARGS, (char *)"swig_dummy_type_isample_vector___getslice__(swig_dummy_type_isample_vector self, std::vector< ISample * >::difference_type i, std::vector< ISample * >::difference_type j) -> swig_dummy_type_isample_vector"},
 	 { (char *)"swig_dummy_type_isample_vector___setslice__", _wrap_swig_dummy_type_isample_vector___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< ISample * >::difference_type i, std::vector< ISample * >::difference_type j)\n"
-		"swig_dummy_type_isample_vector___setslice__(swig_dummy_type_isample_vector self, std::vector< ISample * >::difference_type i, std::vector< ISample * >::difference_type j, swig_dummy_type_isample_vector v)\n"
+		"__setslice__(std::vector< ISample * >::difference_type i, std::vector< ISample * >::difference_type j, swig_dummy_type_isample_vector v)\n"
+		"swig_dummy_type_isample_vector___setslice__(swig_dummy_type_isample_vector self, std::vector< ISample * >::difference_type i, std::vector< ISample * >::difference_type j)\n"
 		""},
 	 { (char *)"swig_dummy_type_isample_vector___delslice__", _wrap_swig_dummy_type_isample_vector___delslice__, METH_VARARGS, (char *)"swig_dummy_type_isample_vector___delslice__(swig_dummy_type_isample_vector self, std::vector< ISample * >::difference_type i, std::vector< ISample * >::difference_type j)"},
 	 { (char *)"swig_dummy_type_isample_vector___delitem__", _wrap_swig_dummy_type_isample_vector___delitem__, METH_VARARGS, (char *)"\n"
@@ -165220,17 +165092,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"swig_dummy_type_isample_vector___setitem__(swig_dummy_type_isample_vector self, std::vector< ISample * >::difference_type i, ISample x)\n"
 		""},
-	 { (char *)"swig_dummy_type_isample_vector_pop", _wrap_swig_dummy_type_isample_vector_pop, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_pop(swig_dummy_type_isample_vector self) -> ISample"},
 	 { (char *)"swig_dummy_type_isample_vector_append", _wrap_swig_dummy_type_isample_vector_append, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_append(swig_dummy_type_isample_vector self, ISample x)"},
 	 { (char *)"swig_dummy_type_isample_vector_empty", _wrap_swig_dummy_type_isample_vector_empty, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_empty(swig_dummy_type_isample_vector self) -> bool"},
 	 { (char *)"swig_dummy_type_isample_vector_size", _wrap_swig_dummy_type_isample_vector_size, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_size(swig_dummy_type_isample_vector self) -> std::vector< ISample * >::size_type"},
+	 { (char *)"swig_dummy_type_isample_vector_clear", _wrap_swig_dummy_type_isample_vector_clear, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_clear(swig_dummy_type_isample_vector self)"},
 	 { (char *)"swig_dummy_type_isample_vector_swap", _wrap_swig_dummy_type_isample_vector_swap, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_swap(swig_dummy_type_isample_vector self, swig_dummy_type_isample_vector v)"},
+	 { (char *)"swig_dummy_type_isample_vector_get_allocator", _wrap_swig_dummy_type_isample_vector_get_allocator, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_get_allocator(swig_dummy_type_isample_vector self) -> std::vector< ISample * >::allocator_type"},
 	 { (char *)"swig_dummy_type_isample_vector_begin", _wrap_swig_dummy_type_isample_vector_begin, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_begin(swig_dummy_type_isample_vector self) -> std::vector< ISample * >::iterator"},
 	 { (char *)"swig_dummy_type_isample_vector_end", _wrap_swig_dummy_type_isample_vector_end, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_end(swig_dummy_type_isample_vector self) -> std::vector< ISample * >::iterator"},
 	 { (char *)"swig_dummy_type_isample_vector_rbegin", _wrap_swig_dummy_type_isample_vector_rbegin, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_rbegin(swig_dummy_type_isample_vector self) -> std::vector< ISample * >::reverse_iterator"},
 	 { (char *)"swig_dummy_type_isample_vector_rend", _wrap_swig_dummy_type_isample_vector_rend, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_rend(swig_dummy_type_isample_vector self) -> std::vector< ISample * >::reverse_iterator"},
-	 { (char *)"swig_dummy_type_isample_vector_clear", _wrap_swig_dummy_type_isample_vector_clear, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_clear(swig_dummy_type_isample_vector self)"},
-	 { (char *)"swig_dummy_type_isample_vector_get_allocator", _wrap_swig_dummy_type_isample_vector_get_allocator, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_get_allocator(swig_dummy_type_isample_vector self) -> std::vector< ISample * >::allocator_type"},
 	 { (char *)"swig_dummy_type_isample_vector_pop_back", _wrap_swig_dummy_type_isample_vector_pop_back, METH_VARARGS, (char *)"swig_dummy_type_isample_vector_pop_back(swig_dummy_type_isample_vector self)"},
 	 { (char *)"swig_dummy_type_isample_vector_erase", _wrap_swig_dummy_type_isample_vector_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< ISample * >::iterator pos) -> std::vector< ISample * >::iterator\n"
@@ -165262,10 +165133,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"swig_dummy_type_const_isample_vector___nonzero__", _wrap_swig_dummy_type_const_isample_vector___nonzero__, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector___nonzero__(swig_dummy_type_const_isample_vector self) -> bool"},
 	 { (char *)"swig_dummy_type_const_isample_vector___bool__", _wrap_swig_dummy_type_const_isample_vector___bool__, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector___bool__(swig_dummy_type_const_isample_vector self) -> bool"},
 	 { (char *)"swig_dummy_type_const_isample_vector___len__", _wrap_swig_dummy_type_const_isample_vector___len__, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector___len__(swig_dummy_type_const_isample_vector self) -> std::vector< ISample const * >::size_type"},
+	 { (char *)"swig_dummy_type_const_isample_vector_pop", _wrap_swig_dummy_type_const_isample_vector_pop, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_pop(swig_dummy_type_const_isample_vector self) -> ISample"},
 	 { (char *)"swig_dummy_type_const_isample_vector___getslice__", _wrap_swig_dummy_type_const_isample_vector___getslice__, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector___getslice__(swig_dummy_type_const_isample_vector self, std::vector< ISample const * >::difference_type i, std::vector< ISample const * >::difference_type j) -> swig_dummy_type_const_isample_vector"},
 	 { (char *)"swig_dummy_type_const_isample_vector___setslice__", _wrap_swig_dummy_type_const_isample_vector___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< ISample const * >::difference_type i, std::vector< ISample const * >::difference_type j)\n"
-		"swig_dummy_type_const_isample_vector___setslice__(swig_dummy_type_const_isample_vector self, std::vector< ISample const * >::difference_type i, std::vector< ISample const * >::difference_type j, swig_dummy_type_const_isample_vector v)\n"
+		"__setslice__(std::vector< ISample const * >::difference_type i, std::vector< ISample const * >::difference_type j, swig_dummy_type_const_isample_vector v)\n"
+		"swig_dummy_type_const_isample_vector___setslice__(swig_dummy_type_const_isample_vector self, std::vector< ISample const * >::difference_type i, std::vector< ISample const * >::difference_type j)\n"
 		""},
 	 { (char *)"swig_dummy_type_const_isample_vector___delslice__", _wrap_swig_dummy_type_const_isample_vector___delslice__, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector___delslice__(swig_dummy_type_const_isample_vector self, std::vector< ISample const * >::difference_type i, std::vector< ISample const * >::difference_type j)"},
 	 { (char *)"swig_dummy_type_const_isample_vector___delitem__", _wrap_swig_dummy_type_const_isample_vector___delitem__, METH_VARARGS, (char *)"\n"
@@ -165281,17 +165153,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"swig_dummy_type_const_isample_vector___setitem__(swig_dummy_type_const_isample_vector self, std::vector< ISample const * >::difference_type i, ISample x)\n"
 		""},
-	 { (char *)"swig_dummy_type_const_isample_vector_pop", _wrap_swig_dummy_type_const_isample_vector_pop, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_pop(swig_dummy_type_const_isample_vector self) -> ISample"},
 	 { (char *)"swig_dummy_type_const_isample_vector_append", _wrap_swig_dummy_type_const_isample_vector_append, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_append(swig_dummy_type_const_isample_vector self, ISample x)"},
 	 { (char *)"swig_dummy_type_const_isample_vector_empty", _wrap_swig_dummy_type_const_isample_vector_empty, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_empty(swig_dummy_type_const_isample_vector self) -> bool"},
 	 { (char *)"swig_dummy_type_const_isample_vector_size", _wrap_swig_dummy_type_const_isample_vector_size, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_size(swig_dummy_type_const_isample_vector self) -> std::vector< ISample const * >::size_type"},
+	 { (char *)"swig_dummy_type_const_isample_vector_clear", _wrap_swig_dummy_type_const_isample_vector_clear, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_clear(swig_dummy_type_const_isample_vector self)"},
 	 { (char *)"swig_dummy_type_const_isample_vector_swap", _wrap_swig_dummy_type_const_isample_vector_swap, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_swap(swig_dummy_type_const_isample_vector self, swig_dummy_type_const_isample_vector v)"},
+	 { (char *)"swig_dummy_type_const_isample_vector_get_allocator", _wrap_swig_dummy_type_const_isample_vector_get_allocator, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_get_allocator(swig_dummy_type_const_isample_vector self) -> std::vector< ISample const * >::allocator_type"},
 	 { (char *)"swig_dummy_type_const_isample_vector_begin", _wrap_swig_dummy_type_const_isample_vector_begin, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_begin(swig_dummy_type_const_isample_vector self) -> std::vector< ISample const * >::iterator"},
 	 { (char *)"swig_dummy_type_const_isample_vector_end", _wrap_swig_dummy_type_const_isample_vector_end, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_end(swig_dummy_type_const_isample_vector self) -> std::vector< ISample const * >::iterator"},
 	 { (char *)"swig_dummy_type_const_isample_vector_rbegin", _wrap_swig_dummy_type_const_isample_vector_rbegin, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_rbegin(swig_dummy_type_const_isample_vector self) -> std::vector< ISample const * >::reverse_iterator"},
 	 { (char *)"swig_dummy_type_const_isample_vector_rend", _wrap_swig_dummy_type_const_isample_vector_rend, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_rend(swig_dummy_type_const_isample_vector self) -> std::vector< ISample const * >::reverse_iterator"},
-	 { (char *)"swig_dummy_type_const_isample_vector_clear", _wrap_swig_dummy_type_const_isample_vector_clear, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_clear(swig_dummy_type_const_isample_vector self)"},
-	 { (char *)"swig_dummy_type_const_isample_vector_get_allocator", _wrap_swig_dummy_type_const_isample_vector_get_allocator, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_get_allocator(swig_dummy_type_const_isample_vector self) -> std::vector< ISample const * >::allocator_type"},
 	 { (char *)"swig_dummy_type_const_isample_vector_pop_back", _wrap_swig_dummy_type_const_isample_vector_pop_back, METH_VARARGS, (char *)"swig_dummy_type_const_isample_vector_pop_back(swig_dummy_type_const_isample_vector self)"},
 	 { (char *)"swig_dummy_type_const_isample_vector_erase", _wrap_swig_dummy_type_const_isample_vector_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< ISample const * >::iterator pos) -> std::vector< ISample const * >::iterator\n"
@@ -167150,10 +167021,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_IFormFactorPtr_t___nonzero__", _wrap_vector_IFormFactorPtr_t___nonzero__, METH_VARARGS, (char *)"vector_IFormFactorPtr_t___nonzero__(vector_IFormFactorPtr_t self) -> bool"},
 	 { (char *)"vector_IFormFactorPtr_t___bool__", _wrap_vector_IFormFactorPtr_t___bool__, METH_VARARGS, (char *)"vector_IFormFactorPtr_t___bool__(vector_IFormFactorPtr_t self) -> bool"},
 	 { (char *)"vector_IFormFactorPtr_t___len__", _wrap_vector_IFormFactorPtr_t___len__, METH_VARARGS, (char *)"vector_IFormFactorPtr_t___len__(vector_IFormFactorPtr_t self) -> std::vector< IFormFactor * >::size_type"},
+	 { (char *)"vector_IFormFactorPtr_t_pop", _wrap_vector_IFormFactorPtr_t_pop, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_pop(vector_IFormFactorPtr_t self) -> IFormFactor"},
 	 { (char *)"vector_IFormFactorPtr_t___getslice__", _wrap_vector_IFormFactorPtr_t___getslice__, METH_VARARGS, (char *)"vector_IFormFactorPtr_t___getslice__(vector_IFormFactorPtr_t self, std::vector< IFormFactor * >::difference_type i, std::vector< IFormFactor * >::difference_type j) -> vector_IFormFactorPtr_t"},
 	 { (char *)"vector_IFormFactorPtr_t___setslice__", _wrap_vector_IFormFactorPtr_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< IFormFactor * >::difference_type i, std::vector< IFormFactor * >::difference_type j)\n"
-		"vector_IFormFactorPtr_t___setslice__(vector_IFormFactorPtr_t self, std::vector< IFormFactor * >::difference_type i, std::vector< IFormFactor * >::difference_type j, vector_IFormFactorPtr_t v)\n"
+		"__setslice__(std::vector< IFormFactor * >::difference_type i, std::vector< IFormFactor * >::difference_type j, vector_IFormFactorPtr_t v)\n"
+		"vector_IFormFactorPtr_t___setslice__(vector_IFormFactorPtr_t self, std::vector< IFormFactor * >::difference_type i, std::vector< IFormFactor * >::difference_type j)\n"
 		""},
 	 { (char *)"vector_IFormFactorPtr_t___delslice__", _wrap_vector_IFormFactorPtr_t___delslice__, METH_VARARGS, (char *)"vector_IFormFactorPtr_t___delslice__(vector_IFormFactorPtr_t self, std::vector< IFormFactor * >::difference_type i, std::vector< IFormFactor * >::difference_type j)"},
 	 { (char *)"vector_IFormFactorPtr_t___delitem__", _wrap_vector_IFormFactorPtr_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -167169,17 +167041,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_IFormFactorPtr_t___setitem__(vector_IFormFactorPtr_t self, std::vector< IFormFactor * >::difference_type i, IFormFactor x)\n"
 		""},
-	 { (char *)"vector_IFormFactorPtr_t_pop", _wrap_vector_IFormFactorPtr_t_pop, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_pop(vector_IFormFactorPtr_t self) -> IFormFactor"},
 	 { (char *)"vector_IFormFactorPtr_t_append", _wrap_vector_IFormFactorPtr_t_append, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_append(vector_IFormFactorPtr_t self, IFormFactor x)"},
 	 { (char *)"vector_IFormFactorPtr_t_empty", _wrap_vector_IFormFactorPtr_t_empty, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_empty(vector_IFormFactorPtr_t self) -> bool"},
 	 { (char *)"vector_IFormFactorPtr_t_size", _wrap_vector_IFormFactorPtr_t_size, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_size(vector_IFormFactorPtr_t self) -> std::vector< IFormFactor * >::size_type"},
+	 { (char *)"vector_IFormFactorPtr_t_clear", _wrap_vector_IFormFactorPtr_t_clear, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_clear(vector_IFormFactorPtr_t self)"},
 	 { (char *)"vector_IFormFactorPtr_t_swap", _wrap_vector_IFormFactorPtr_t_swap, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_swap(vector_IFormFactorPtr_t self, vector_IFormFactorPtr_t v)"},
+	 { (char *)"vector_IFormFactorPtr_t_get_allocator", _wrap_vector_IFormFactorPtr_t_get_allocator, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_get_allocator(vector_IFormFactorPtr_t self) -> std::vector< IFormFactor * >::allocator_type"},
 	 { (char *)"vector_IFormFactorPtr_t_begin", _wrap_vector_IFormFactorPtr_t_begin, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_begin(vector_IFormFactorPtr_t self) -> std::vector< IFormFactor * >::iterator"},
 	 { (char *)"vector_IFormFactorPtr_t_end", _wrap_vector_IFormFactorPtr_t_end, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_end(vector_IFormFactorPtr_t self) -> std::vector< IFormFactor * >::iterator"},
 	 { (char *)"vector_IFormFactorPtr_t_rbegin", _wrap_vector_IFormFactorPtr_t_rbegin, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_rbegin(vector_IFormFactorPtr_t self) -> std::vector< IFormFactor * >::reverse_iterator"},
 	 { (char *)"vector_IFormFactorPtr_t_rend", _wrap_vector_IFormFactorPtr_t_rend, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_rend(vector_IFormFactorPtr_t self) -> std::vector< IFormFactor * >::reverse_iterator"},
-	 { (char *)"vector_IFormFactorPtr_t_clear", _wrap_vector_IFormFactorPtr_t_clear, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_clear(vector_IFormFactorPtr_t self)"},
-	 { (char *)"vector_IFormFactorPtr_t_get_allocator", _wrap_vector_IFormFactorPtr_t_get_allocator, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_get_allocator(vector_IFormFactorPtr_t self) -> std::vector< IFormFactor * >::allocator_type"},
 	 { (char *)"vector_IFormFactorPtr_t_pop_back", _wrap_vector_IFormFactorPtr_t_pop_back, METH_VARARGS, (char *)"vector_IFormFactorPtr_t_pop_back(vector_IFormFactorPtr_t self)"},
 	 { (char *)"vector_IFormFactorPtr_t_erase", _wrap_vector_IFormFactorPtr_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< IFormFactor * >::iterator pos) -> std::vector< IFormFactor * >::iterator\n"
@@ -178314,19 +178185,10 @@ extern "C" {
         0,                                  /* tp_del */
 #endif
 #if PY_VERSION_HEX >= 0x02060000
-        0,                                  /* tp_version_tag */
-#endif
-#if PY_VERSION_HEX >= 0x03040000
-        0,                                  /* tp_finalize */
+        0,                                  /* tp_version */
 #endif
 #ifdef COUNT_ALLOCS
-        0,                                  /* tp_allocs */
-        0,                                  /* tp_frees */
-        0,                                  /* tp_maxalloc */
-#if PY_VERSION_HEX >= 0x02050000
-        0,                                  /* tp_prev */
-#endif
-        0                                   /* tp_next */
+        0,0,0,0                             /* tp_alloc -> tp_next */
 #endif
       };
       varlink_type = tmp;
diff --git a/Core/PythonAPI/libBornAgainCore_wrap.h b/Core/PythonAPI/libBornAgainCore_wrap.h
index 9df0d15542a2ca5b40f3a0c1b871dd234acdfd23..a6b93abd607ab461e61d5154fd42f4ed02a2966e 100644
--- a/Core/PythonAPI/libBornAgainCore_wrap.h
+++ b/Core/PythonAPI/libBornAgainCore_wrap.h
@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 3.0.8
+ * Version 3.0.7
  *
  * This file is not intended to be easily readable and contains a number of
  * coding conventions designed to improve portability and efficiency. Do not make
diff --git a/Examples/python/fitting/ex01_SampleParametersIntro/SampleParametersIntro.py b/Examples/python/fitting/ex01_SampleParametersIntro/SampleParametersIntro.py
index 733770fb43e293192502fb1b29411bad6ce69223..e859cf29acc846c849f358f7ea924fc0712972a5 100644
--- a/Examples/python/fitting/ex01_SampleParametersIntro/SampleParametersIntro.py
+++ b/Examples/python/fitting/ex01_SampleParametersIntro/SampleParametersIntro.py
@@ -54,10 +54,10 @@ def run_simulations():
     """
 
     sample = get_sample()
-    print "The tree structure of the sample"
+    print("The tree structure of the sample")
     sample.printSampleTree()
 
-    print "The sample contains following parameters ('name':value)"
+    print("The sample contains following parameters ('name':value)")
     sample.printParameters()
 
     simulation = get_simulation()
diff --git a/Examples/python/fitting/ex02_FitCylindersAndPrisms/FitCylindersPrisms.py b/Examples/python/fitting/ex02_FitCylindersAndPrisms/FitCylindersPrisms.py
index c89c27fc2347bc60f4d0348c98a67cc631569ca1..6b6fcef93c2808105ce50248f3fd068aadadf903 100644
--- a/Examples/python/fitting/ex02_FitCylindersAndPrisms/FitCylindersPrisms.py
+++ b/Examples/python/fitting/ex02_FitCylindersAndPrisms/FitCylindersPrisms.py
@@ -68,11 +68,11 @@ def run_fitting():
     # running fit
     fit_suite.runFit()
 
-    print "Fitting completed."
-    print "chi2:", fit_suite.getChi2()
+    print("Fitting completed.")
+    print("chi2:", fit_suite.getChi2())
     fitpars = fit_suite.getFitParameters()
     for i in range(0, fitpars.size()):
-        print fitpars[i].getName(), fitpars[i].getValue(), fitpars[i].getError()
+        print(fitpars[i].getName(), fitpars[i].getValue(), fitpars[i].getError())
 
 if __name__ == '__main__':
     run_fitting()
diff --git a/Examples/python/fitting/ex02_FitCylindersAndPrisms/FitCylindersPrisms_detailed.py b/Examples/python/fitting/ex02_FitCylindersAndPrisms/FitCylindersPrisms_detailed.py
index b99684606b89bf33455ec19b0e7832a204239463..65991e98c2f7a41bea87a833fa164058e7d26f70 100644
--- a/Examples/python/fitting/ex02_FitCylindersAndPrisms/FitCylindersPrisms_detailed.py
+++ b/Examples/python/fitting/ex02_FitCylindersAndPrisms/FitCylindersPrisms_detailed.py
@@ -159,11 +159,11 @@ def run_fitting():
     # running fit
     fit_suite.runFit()
 
-    print "Fitting completed."
-    print "chi2:", fit_suite.getChi2()
+    print("Fitting completed.")
+    print("chi2:", fit_suite.getChi2())
     fitpars = fit_suite.getFitParameters()
     for i in range(0, fitpars.size()):
-        print fitpars[i].getName(), fitpars[i].getValue(), fitpars[i].getError()
+        print(fitpars[i].getName(), fitpars[i].getValue(), fitpars[i].getError())
 
 
 if __name__ == '__main__':
diff --git a/Examples/python/fitting/ex03_FitSpheresInHexLattice/FitSpheresInHexLattice.py b/Examples/python/fitting/ex03_FitSpheresInHexLattice/FitSpheresInHexLattice.py
index 802f4040f6e29dea09bf19e5d7b03109621f5656..6b4b7cd77917166cc8572115623d459a74202fd6 100644
--- a/Examples/python/fitting/ex03_FitSpheresInHexLattice/FitSpheresInHexLattice.py
+++ b/Examples/python/fitting/ex03_FitSpheresInHexLattice/FitSpheresInHexLattice.py
@@ -97,11 +97,11 @@ def run_fitting():
     # running fit
     fit_suite.runFit()
 
-    print "Fitting completed."
-    print "chi2:", fit_suite.getChi2()
+    print("Fitting completed.")
+    print("chi2:", fit_suite.getChi2())
     fitpars = fit_suite.getFitParameters()
     for i in range(0, fitpars.size()):
-        print fitpars[i].getName(), fitpars[i].getValue(), fitpars[i].getError()
+        print(fitpars[i].getName(), fitpars[i].getValue(), fitpars[i].getError())
 
 
 if __name__ == '__main__':
diff --git a/Examples/python/fitting/ex03_FitSpheresInHexLattice/FitSpheresInHexLattice_builder.py b/Examples/python/fitting/ex03_FitSpheresInHexLattice/FitSpheresInHexLattice_builder.py
index 195fded88d3af49b27e1e1b55a12a9f7a49562dc..81eebd455a90689f3528e9e006687b9d46fe2445 100644
--- a/Examples/python/fitting/ex03_FitSpheresInHexLattice/FitSpheresInHexLattice_builder.py
+++ b/Examples/python/fitting/ex03_FitSpheresInHexLattice/FitSpheresInHexLattice_builder.py
@@ -115,11 +115,11 @@ def run_fitting():
     # running fit
     fit_suite.runFit()
 
-    print "Fitting completed."
-    print "chi2:", fit_suite.getChi2()
+    print("Fitting completed.")
+    print("chi2:", fit_suite.getChi2())
     fitpars = fit_suite.getFitParameters()
     for i in range(0, fitpars.size()):
-        print fitpars[i].getName(), fitpars[i].getValue(), fitpars[i].getError()
+        print(fitpars[i].getName(), fitpars[i].getValue(), fitpars[i].getError())
 
 
 if __name__ == '__main__':
diff --git a/Examples/python/simulation/ex01_BasicParticles/AllFormFactorsAvailable.py b/Examples/python/simulation/ex01_BasicParticles/AllFormFactorsAvailable.py
index 6c9c96dc3f42823419e2c77f370449f33f5f360f..2a875ea4c4dd60f9a2aee8ed42292ee59e4e1f4a 100644
--- a/Examples/python/simulation/ex01_BasicParticles/AllFormFactorsAvailable.py
+++ b/Examples/python/simulation/ex01_BasicParticles/AllFormFactorsAvailable.py
@@ -75,7 +75,7 @@ def run_simulation():
     for ff in formfactors:
         name = ff.__class__.__name__
         name = name.replace("FormFactor", "")
-        print "Generating intensity map in BA for '{0}'".format(name)
+        print("Generating intensity map in BA for '{0}'".format(name))
 
         sample = get_sample(ff)
         simulation = get_simulation()
diff --git a/Fit/PythonAPI/libBornAgainFit.i b/Fit/PythonAPI/libBornAgainFit.i
index 00b6ebe83ff7e25ccf7769f8144200fe383f3cd1..18c414309b66149fbeff4999dc65318fb69b893c 100644
--- a/Fit/PythonAPI/libBornAgainFit.i
+++ b/Fit/PythonAPI/libBornAgainFit.i
@@ -200,6 +200,7 @@ import_array();
 #include "MathFunctions.h"
 #include "MinimizerFactory.h"
 #include "MinimizerOptions.h"
+#include "FitStrategyAdjustMinimizer.h"
 
 
 
@@ -246,6 +247,7 @@ import_array();
 %include "MinimizerFactory.h"
 %include "MinimizerOptions.h"
 
+%include "FitStrategyAdjustMinimizer.h"
 
 
  /*
diff --git a/Fit/PythonAPI/libBornAgainFit.py b/Fit/PythonAPI/libBornAgainFit.py
index 81e567be4568712d27498f36df8ca95093d45d7b..40f4a3c76f59d656f709f73f3a5f160dfa494f6a 100644
--- a/Fit/PythonAPI/libBornAgainFit.py
+++ b/Fit/PythonAPI/libBornAgainFit.py
@@ -1,5 +1,5 @@
 # This file was automatically generated by SWIG (http://www.swig.org).
-# Version 3.0.8
+# Version 3.0.7
 #
 # Do not make changes to this file unless you know what you are doing--modify
 # the SWIG interface file instead.
@@ -77,7 +77,7 @@ def _swig_getattr(self, class_type, name):
 def _swig_repr(self):
     try:
         strthis = "proxy of " + self.this.__repr__()
-    except Exception:
+    except:
         strthis = ""
     return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
 
@@ -93,13 +93,12 @@ except AttributeError:
 try:
     import weakref
     weakref_proxy = weakref.proxy
-except Exception:
+except:
     weakref_proxy = lambda x: x
 
 
 class SwigPyIterator(_object):
-    """Proxy of C++ swig::SwigPyIterator class."""
-
+    """Proxy of C++ swig::SwigPyIterator class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
     __swig_getmethods__ = {}
@@ -208,8 +207,7 @@ SwigPyIterator_swigregister(SwigPyIterator)
 _libBornAgainFit.SHARED_PTR_DISOWN_swigconstant(_libBornAgainFit)
 SHARED_PTR_DISOWN = _libBornAgainFit.SHARED_PTR_DISOWN
 class vdouble1d_t(_object):
-    """Proxy of C++ std::vector<(double)> class."""
-
+    """Proxy of C++ std::vector<(double)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vdouble1d_t, name, value)
     __swig_getmethods__ = {}
@@ -238,6 +236,11 @@ class vdouble1d_t(_object):
         return _libBornAgainFit.vdouble1d_t___len__(self)
 
 
+    def pop(self):
+        """pop(vdouble1d_t self) -> std::vector< double >::value_type"""
+        return _libBornAgainFit.vdouble1d_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> vdouble1d_t"""
         return _libBornAgainFit.vdouble1d_t___getslice__(self, i, j)
@@ -245,8 +248,8 @@ class vdouble1d_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
         __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, vdouble1d_t v)
+        __setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
         """
         return _libBornAgainFit.vdouble1d_t___setslice__(self, *args)
 
@@ -281,11 +284,6 @@ class vdouble1d_t(_object):
         return _libBornAgainFit.vdouble1d_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vdouble1d_t self) -> std::vector< double >::value_type"""
-        return _libBornAgainFit.vdouble1d_t_pop(self)
-
-
     def append(self, x):
         """append(vdouble1d_t self, std::vector< double >::value_type const & x)"""
         return _libBornAgainFit.vdouble1d_t_append(self, x)
@@ -301,11 +299,21 @@ class vdouble1d_t(_object):
         return _libBornAgainFit.vdouble1d_t_size(self)
 
 
+    def clear(self):
+        """clear(vdouble1d_t self)"""
+        return _libBornAgainFit.vdouble1d_t_clear(self)
+
+
     def swap(self, v):
         """swap(vdouble1d_t self, vdouble1d_t v)"""
         return _libBornAgainFit.vdouble1d_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"""
+        return _libBornAgainFit.vdouble1d_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vdouble1d_t self) -> std::vector< double >::iterator"""
         return _libBornAgainFit.vdouble1d_t_begin(self)
@@ -326,16 +334,6 @@ class vdouble1d_t(_object):
         return _libBornAgainFit.vdouble1d_t_rend(self)
 
 
-    def clear(self):
-        """clear(vdouble1d_t self)"""
-        return _libBornAgainFit.vdouble1d_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"""
-        return _libBornAgainFit.vdouble1d_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vdouble1d_t self)"""
         return _libBornAgainFit.vdouble1d_t_pop_back(self)
@@ -359,7 +357,7 @@ class vdouble1d_t(_object):
         this = _libBornAgainFit.new_vdouble1d_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -413,8 +411,7 @@ vdouble1d_t_swigregister = _libBornAgainFit.vdouble1d_t_swigregister
 vdouble1d_t_swigregister(vdouble1d_t)
 
 class vdouble2d_t(_object):
-    """Proxy of C++ std::vector<(std::vector<(double)>)> class."""
-
+    """Proxy of C++ std::vector<(std::vector<(double)>)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vdouble2d_t, name, value)
     __swig_getmethods__ = {}
@@ -443,6 +440,11 @@ class vdouble2d_t(_object):
         return _libBornAgainFit.vdouble2d_t___len__(self)
 
 
+    def pop(self):
+        """pop(vdouble2d_t self) -> vdouble1d_t"""
+        return _libBornAgainFit.vdouble2d_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> vdouble2d_t"""
         return _libBornAgainFit.vdouble2d_t___getslice__(self, i, j)
@@ -450,8 +452,8 @@ class vdouble2d_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)
         __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, vdouble2d_t v)
+        __setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)
         """
         return _libBornAgainFit.vdouble2d_t___setslice__(self, *args)
 
@@ -486,11 +488,6 @@ class vdouble2d_t(_object):
         return _libBornAgainFit.vdouble2d_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vdouble2d_t self) -> vdouble1d_t"""
-        return _libBornAgainFit.vdouble2d_t_pop(self)
-
-
     def append(self, x):
         """append(vdouble2d_t self, vdouble1d_t x)"""
         return _libBornAgainFit.vdouble2d_t_append(self, x)
@@ -506,11 +503,21 @@ class vdouble2d_t(_object):
         return _libBornAgainFit.vdouble2d_t_size(self)
 
 
+    def clear(self):
+        """clear(vdouble2d_t self)"""
+        return _libBornAgainFit.vdouble2d_t_clear(self)
+
+
     def swap(self, v):
         """swap(vdouble2d_t self, vdouble2d_t v)"""
         return _libBornAgainFit.vdouble2d_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"""
+        return _libBornAgainFit.vdouble2d_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"""
         return _libBornAgainFit.vdouble2d_t_begin(self)
@@ -531,16 +538,6 @@ class vdouble2d_t(_object):
         return _libBornAgainFit.vdouble2d_t_rend(self)
 
 
-    def clear(self):
-        """clear(vdouble2d_t self)"""
-        return _libBornAgainFit.vdouble2d_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"""
-        return _libBornAgainFit.vdouble2d_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vdouble2d_t self)"""
         return _libBornAgainFit.vdouble2d_t_pop_back(self)
@@ -564,7 +561,7 @@ class vdouble2d_t(_object):
         this = _libBornAgainFit.new_vdouble2d_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -618,8 +615,7 @@ vdouble2d_t_swigregister = _libBornAgainFit.vdouble2d_t_swigregister
 vdouble2d_t_swigregister(vdouble2d_t)
 
 class vector_integer_t(_object):
-    """Proxy of C++ std::vector<(int)> class."""
-
+    """Proxy of C++ std::vector<(int)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_integer_t, name, value)
     __swig_getmethods__ = {}
@@ -648,6 +644,11 @@ class vector_integer_t(_object):
         return _libBornAgainFit.vector_integer_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_integer_t self) -> std::vector< int >::value_type"""
+        return _libBornAgainFit.vector_integer_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> vector_integer_t"""
         return _libBornAgainFit.vector_integer_t___getslice__(self, i, j)
@@ -655,8 +656,8 @@ class vector_integer_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
         __setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, vector_integer_t v)
+        __setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
         """
         return _libBornAgainFit.vector_integer_t___setslice__(self, *args)
 
@@ -691,11 +692,6 @@ class vector_integer_t(_object):
         return _libBornAgainFit.vector_integer_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_integer_t self) -> std::vector< int >::value_type"""
-        return _libBornAgainFit.vector_integer_t_pop(self)
-
-
     def append(self, x):
         """append(vector_integer_t self, std::vector< int >::value_type const & x)"""
         return _libBornAgainFit.vector_integer_t_append(self, x)
@@ -711,11 +707,21 @@ class vector_integer_t(_object):
         return _libBornAgainFit.vector_integer_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_integer_t self)"""
+        return _libBornAgainFit.vector_integer_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_integer_t self, vector_integer_t v)"""
         return _libBornAgainFit.vector_integer_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"""
+        return _libBornAgainFit.vector_integer_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_integer_t self) -> std::vector< int >::iterator"""
         return _libBornAgainFit.vector_integer_t_begin(self)
@@ -736,16 +742,6 @@ class vector_integer_t(_object):
         return _libBornAgainFit.vector_integer_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_integer_t self)"""
-        return _libBornAgainFit.vector_integer_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"""
-        return _libBornAgainFit.vector_integer_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_integer_t self)"""
         return _libBornAgainFit.vector_integer_t_pop_back(self)
@@ -769,7 +765,7 @@ class vector_integer_t(_object):
         this = _libBornAgainFit.new_vector_integer_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -823,8 +819,7 @@ vector_integer_t_swigregister = _libBornAgainFit.vector_integer_t_swigregister
 vector_integer_t_swigregister(vector_integer_t)
 
 class vector_longinteger_t(_object):
-    """Proxy of C++ std::vector<(unsigned long)> class."""
-
+    """Proxy of C++ std::vector<(unsigned long)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_longinteger_t, name, value)
     __swig_getmethods__ = {}
@@ -853,6 +848,11 @@ class vector_longinteger_t(_object):
         return _libBornAgainFit.vector_longinteger_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"""
+        return _libBornAgainFit.vector_longinteger_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j) -> vector_longinteger_t"""
         return _libBornAgainFit.vector_longinteger_t___getslice__(self, i, j)
@@ -860,8 +860,8 @@ class vector_longinteger_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)
         __setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, vector_longinteger_t v)
+        __setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)
         """
         return _libBornAgainFit.vector_longinteger_t___setslice__(self, *args)
 
@@ -896,11 +896,6 @@ class vector_longinteger_t(_object):
         return _libBornAgainFit.vector_longinteger_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"""
-        return _libBornAgainFit.vector_longinteger_t_pop(self)
-
-
     def append(self, x):
         """append(vector_longinteger_t self, std::vector< unsigned long >::value_type const & x)"""
         return _libBornAgainFit.vector_longinteger_t_append(self, x)
@@ -916,11 +911,21 @@ class vector_longinteger_t(_object):
         return _libBornAgainFit.vector_longinteger_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_longinteger_t self)"""
+        return _libBornAgainFit.vector_longinteger_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_longinteger_t self, vector_longinteger_t v)"""
         return _libBornAgainFit.vector_longinteger_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"""
+        return _libBornAgainFit.vector_longinteger_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"""
         return _libBornAgainFit.vector_longinteger_t_begin(self)
@@ -941,16 +946,6 @@ class vector_longinteger_t(_object):
         return _libBornAgainFit.vector_longinteger_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_longinteger_t self)"""
-        return _libBornAgainFit.vector_longinteger_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"""
-        return _libBornAgainFit.vector_longinteger_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_longinteger_t self)"""
         return _libBornAgainFit.vector_longinteger_t_pop_back(self)
@@ -974,7 +969,7 @@ class vector_longinteger_t(_object):
         this = _libBornAgainFit.new_vector_longinteger_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -1028,8 +1023,7 @@ vector_longinteger_t_swigregister = _libBornAgainFit.vector_longinteger_t_swigre
 vector_longinteger_t_swigregister(vector_longinteger_t)
 
 class vector_complex_t(_object):
-    """Proxy of C++ std::vector<(std::complex<(double)>)> class."""
-
+    """Proxy of C++ std::vector<(std::complex<(double)>)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_complex_t, name, value)
     __swig_getmethods__ = {}
@@ -1058,6 +1052,11 @@ class vector_complex_t(_object):
         return _libBornAgainFit.vector_complex_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"""
+        return _libBornAgainFit.vector_complex_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j) -> vector_complex_t"""
         return _libBornAgainFit.vector_complex_t___getslice__(self, i, j)
@@ -1065,8 +1064,8 @@ class vector_complex_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)
         __setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, vector_complex_t v)
+        __setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)
         """
         return _libBornAgainFit.vector_complex_t___setslice__(self, *args)
 
@@ -1101,11 +1100,6 @@ class vector_complex_t(_object):
         return _libBornAgainFit.vector_complex_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"""
-        return _libBornAgainFit.vector_complex_t_pop(self)
-
-
     def append(self, x):
         """append(vector_complex_t self, std::vector< std::complex< double > >::value_type const & x)"""
         return _libBornAgainFit.vector_complex_t_append(self, x)
@@ -1121,11 +1115,21 @@ class vector_complex_t(_object):
         return _libBornAgainFit.vector_complex_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_complex_t self)"""
+        return _libBornAgainFit.vector_complex_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_complex_t self, vector_complex_t v)"""
         return _libBornAgainFit.vector_complex_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"""
+        return _libBornAgainFit.vector_complex_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"""
         return _libBornAgainFit.vector_complex_t_begin(self)
@@ -1146,16 +1150,6 @@ class vector_complex_t(_object):
         return _libBornAgainFit.vector_complex_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_complex_t self)"""
-        return _libBornAgainFit.vector_complex_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"""
-        return _libBornAgainFit.vector_complex_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_complex_t self)"""
         return _libBornAgainFit.vector_complex_t_pop_back(self)
@@ -1179,7 +1173,7 @@ class vector_complex_t(_object):
         this = _libBornAgainFit.new_vector_complex_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -1233,8 +1227,7 @@ vector_complex_t_swigregister = _libBornAgainFit.vector_complex_t_swigregister
 vector_complex_t_swigregister(vector_complex_t)
 
 class vector_string_t(_object):
-    """Proxy of C++ std::vector<(std::string)> class."""
-
+    """Proxy of C++ std::vector<(std::string)> class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, vector_string_t, name, value)
     __swig_getmethods__ = {}
@@ -1263,6 +1256,11 @@ class vector_string_t(_object):
         return _libBornAgainFit.vector_string_t___len__(self)
 
 
+    def pop(self):
+        """pop(vector_string_t self) -> std::vector< std::string >::value_type"""
+        return _libBornAgainFit.vector_string_t_pop(self)
+
+
     def __getslice__(self, i, j):
         """__getslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> vector_string_t"""
         return _libBornAgainFit.vector_string_t___getslice__(self, i, j)
@@ -1270,8 +1268,8 @@ class vector_string_t(_object):
 
     def __setslice__(self, *args):
         """
-        __setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
         __setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, vector_string_t v)
+        __setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
         """
         return _libBornAgainFit.vector_string_t___setslice__(self, *args)
 
@@ -1306,11 +1304,6 @@ class vector_string_t(_object):
         return _libBornAgainFit.vector_string_t___setitem__(self, *args)
 
 
-    def pop(self):
-        """pop(vector_string_t self) -> std::vector< std::string >::value_type"""
-        return _libBornAgainFit.vector_string_t_pop(self)
-
-
     def append(self, x):
         """append(vector_string_t self, std::vector< std::string >::value_type const & x)"""
         return _libBornAgainFit.vector_string_t_append(self, x)
@@ -1326,11 +1319,21 @@ class vector_string_t(_object):
         return _libBornAgainFit.vector_string_t_size(self)
 
 
+    def clear(self):
+        """clear(vector_string_t self)"""
+        return _libBornAgainFit.vector_string_t_clear(self)
+
+
     def swap(self, v):
         """swap(vector_string_t self, vector_string_t v)"""
         return _libBornAgainFit.vector_string_t_swap(self, v)
 
 
+    def get_allocator(self):
+        """get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"""
+        return _libBornAgainFit.vector_string_t_get_allocator(self)
+
+
     def begin(self):
         """begin(vector_string_t self) -> std::vector< std::string >::iterator"""
         return _libBornAgainFit.vector_string_t_begin(self)
@@ -1351,16 +1354,6 @@ class vector_string_t(_object):
         return _libBornAgainFit.vector_string_t_rend(self)
 
 
-    def clear(self):
-        """clear(vector_string_t self)"""
-        return _libBornAgainFit.vector_string_t_clear(self)
-
-
-    def get_allocator(self):
-        """get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"""
-        return _libBornAgainFit.vector_string_t_get_allocator(self)
-
-
     def pop_back(self):
         """pop_back(vector_string_t self)"""
         return _libBornAgainFit.vector_string_t_pop_back(self)
@@ -1384,7 +1377,7 @@ class vector_string_t(_object):
         this = _libBornAgainFit.new_vector_string_t(*args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def push_back(self, x):
@@ -1442,8 +1435,7 @@ _libBornAgainFit.GCCXML_SKIP_THIS_swigconstant(_libBornAgainFit)
 GCCXML_SKIP_THIS = _libBornAgainFit.GCCXML_SKIP_THIS
 import libBornAgainCore
 class IChiSquaredModule(libBornAgainCore.ICloneable):
-    """Proxy of C++ IChiSquaredModule class."""
-
+    """Proxy of C++ IChiSquaredModule class"""
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.ICloneable]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -1514,7 +1506,7 @@ class IChiSquaredModule(libBornAgainCore.ICloneable):
         this = _libBornAgainFit.new_IChiSquaredModule(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -1532,7 +1524,6 @@ class IFitObserver(libBornAgainCore.IObserver):
     C++ includes: IFitObserver.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.IObserver]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -1557,7 +1548,7 @@ class IFitObserver(libBornAgainCore.IObserver):
         this = _libBornAgainFit.new_IFitObserver(_self, update_every_nth)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def notify(self, subject):
@@ -1603,7 +1594,6 @@ class IFitStrategy(libBornAgainCore.INamed):
     C++ includes: IFitStrategy.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.INamed]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -1667,7 +1657,7 @@ class IFitStrategy(libBornAgainCore.INamed):
         this = _libBornAgainFit.new_IFitStrategy(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -1685,7 +1675,6 @@ class FitStrategyDefault(IFitStrategy):
     C++ includes: IFitStrategy.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [IFitStrategy]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -1710,7 +1699,7 @@ class FitStrategyDefault(IFitStrategy):
         this = _libBornAgainFit.new_FitStrategyDefault(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def clone(self):
@@ -1747,8 +1736,7 @@ FitStrategyDefault_swigregister = _libBornAgainFit.FitStrategyDefault_swigregist
 FitStrategyDefault_swigregister(FitStrategyDefault)
 
 class IIntensityFunction(_object):
-    """Proxy of C++ IIntensityFunction class."""
-
+    """Proxy of C++ IIntensityFunction class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, IIntensityFunction, name, value)
     __swig_getmethods__ = {}
@@ -1776,7 +1764,7 @@ class IIntensityFunction(_object):
         this = _libBornAgainFit.new_IIntensityFunction(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -1786,8 +1774,7 @@ IIntensityFunction_swigregister = _libBornAgainFit.IIntensityFunction_swigregist
 IIntensityFunction_swigregister(IIntensityFunction)
 
 class IntensityFunctionLog(IIntensityFunction):
-    """Proxy of C++ IntensityFunctionLog class."""
-
+    """Proxy of C++ IntensityFunctionLog class"""
     __swig_setmethods__ = {}
     for _s in [IIntensityFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -1819,7 +1806,7 @@ class IntensityFunctionLog(IIntensityFunction):
         this = _libBornAgainFit.new_IntensityFunctionLog(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -1829,8 +1816,7 @@ IntensityFunctionLog_swigregister = _libBornAgainFit.IntensityFunctionLog_swigre
 IntensityFunctionLog_swigregister(IntensityFunctionLog)
 
 class IntensityFunctionSqrt(IIntensityFunction):
-    """Proxy of C++ IntensityFunctionSqrt class."""
-
+    """Proxy of C++ IntensityFunctionSqrt class"""
     __swig_setmethods__ = {}
     for _s in [IIntensityFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -1862,7 +1848,7 @@ class IntensityFunctionSqrt(IIntensityFunction):
         this = _libBornAgainFit.new_IntensityFunctionSqrt(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -1872,8 +1858,7 @@ IntensityFunctionSqrt_swigregister = _libBornAgainFit.IntensityFunctionSqrt_swig
 IntensityFunctionSqrt_swigregister(IntensityFunctionSqrt)
 
 class IIntensityNormalizer(libBornAgainCore.IParameterized):
-    """Proxy of C++ IIntensityNormalizer class."""
-
+    """Proxy of C++ IIntensityNormalizer class"""
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -1915,7 +1900,7 @@ class IIntensityNormalizer(libBornAgainCore.IParameterized):
         this = _libBornAgainFit.new_IIntensityNormalizer(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     def __disown__(self):
         self.this.disown()
@@ -1935,8 +1920,7 @@ IIntensityNormalizer_swigregister = _libBornAgainFit.IIntensityNormalizer_swigre
 IIntensityNormalizer_swigregister(IIntensityNormalizer)
 
 class IntensityNormalizer(IIntensityNormalizer):
-    """Proxy of C++ IntensityNormalizer class."""
-
+    """Proxy of C++ IntensityNormalizer class"""
     __swig_setmethods__ = {}
     for _s in [IIntensityNormalizer]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -1960,7 +1944,7 @@ class IntensityNormalizer(IIntensityNormalizer):
         this = _libBornAgainFit.new_IntensityNormalizer(_self, scale, shift)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_IntensityNormalizer
     __del__ = lambda self: None
@@ -2002,8 +1986,7 @@ IntensityNormalizer_swigregister = _libBornAgainFit.IntensityNormalizer_swigregi
 IntensityNormalizer_swigregister(IntensityNormalizer)
 
 class IntensityScaleAndShiftNormalizer(IntensityNormalizer):
-    """Proxy of C++ IntensityScaleAndShiftNormalizer class."""
-
+    """Proxy of C++ IntensityScaleAndShiftNormalizer class"""
     __swig_setmethods__ = {}
     for _s in [IntensityNormalizer]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2027,7 +2010,7 @@ class IntensityScaleAndShiftNormalizer(IntensityNormalizer):
         this = _libBornAgainFit.new_IntensityScaleAndShiftNormalizer(_self, scale, shift)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_IntensityScaleAndShiftNormalizer
     __del__ = lambda self: None
@@ -2059,8 +2042,7 @@ IntensityScaleAndShiftNormalizer_swigregister = _libBornAgainFit.IntensityScaleA
 IntensityScaleAndShiftNormalizer_swigregister(IntensityScaleAndShiftNormalizer)
 
 class ISquaredFunction(_object):
-    """Proxy of C++ ISquaredFunction class."""
-
+    """Proxy of C++ ISquaredFunction class"""
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, ISquaredFunction, name, value)
     __swig_getmethods__ = {}
@@ -2076,7 +2058,7 @@ class ISquaredFunction(_object):
         this = _libBornAgainFit.new_ISquaredFunction(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_ISquaredFunction
     __del__ = lambda self: None
@@ -2106,8 +2088,7 @@ ISquaredFunction_swigregister = _libBornAgainFit.ISquaredFunction_swigregister
 ISquaredFunction_swigregister(ISquaredFunction)
 
 class SquaredFunctionDefault(ISquaredFunction):
-    """Proxy of C++ SquaredFunctionDefault class."""
-
+    """Proxy of C++ SquaredFunctionDefault class"""
     __swig_setmethods__ = {}
     for _s in [ISquaredFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2127,7 +2108,7 @@ class SquaredFunctionDefault(ISquaredFunction):
         this = _libBornAgainFit.new_SquaredFunctionDefault(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_SquaredFunctionDefault
     __del__ = lambda self: None
@@ -2157,8 +2138,7 @@ SquaredFunctionDefault_swigregister = _libBornAgainFit.SquaredFunctionDefault_sw
 SquaredFunctionDefault_swigregister(SquaredFunctionDefault)
 
 class SquaredFunctionSimError(ISquaredFunction):
-    """Proxy of C++ SquaredFunctionSimError class."""
-
+    """Proxy of C++ SquaredFunctionSimError class"""
     __swig_setmethods__ = {}
     for _s in [ISquaredFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2178,7 +2158,7 @@ class SquaredFunctionSimError(ISquaredFunction):
         this = _libBornAgainFit.new_SquaredFunctionSimError(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_SquaredFunctionSimError
     __del__ = lambda self: None
@@ -2205,8 +2185,7 @@ SquaredFunctionSimError_swigregister = _libBornAgainFit.SquaredFunctionSimError_
 SquaredFunctionSimError_swigregister(SquaredFunctionSimError)
 
 class SquaredFunctionMeanSquaredError(ISquaredFunction):
-    """Proxy of C++ SquaredFunctionMeanSquaredError class."""
-
+    """Proxy of C++ SquaredFunctionMeanSquaredError class"""
     __swig_setmethods__ = {}
     for _s in [ISquaredFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2226,7 +2205,7 @@ class SquaredFunctionMeanSquaredError(ISquaredFunction):
         this = _libBornAgainFit.new_SquaredFunctionMeanSquaredError(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_SquaredFunctionMeanSquaredError
     __del__ = lambda self: None
@@ -2253,8 +2232,7 @@ SquaredFunctionMeanSquaredError_swigregister = _libBornAgainFit.SquaredFunctionM
 SquaredFunctionMeanSquaredError_swigregister(SquaredFunctionMeanSquaredError)
 
 class SquaredFunctionSystematicError(ISquaredFunction):
-    """Proxy of C++ SquaredFunctionSystematicError class."""
-
+    """Proxy of C++ SquaredFunctionSystematicError class"""
     __swig_setmethods__ = {}
     for _s in [ISquaredFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2277,7 +2255,7 @@ class SquaredFunctionSystematicError(ISquaredFunction):
         this = _libBornAgainFit.new_SquaredFunctionSystematicError(_self, epsilon)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_SquaredFunctionSystematicError
     __del__ = lambda self: None
@@ -2304,8 +2282,7 @@ SquaredFunctionSystematicError_swigregister = _libBornAgainFit.SquaredFunctionSy
 SquaredFunctionSystematicError_swigregister(SquaredFunctionSystematicError)
 
 class SquaredFunctionGaussianError(ISquaredFunction):
-    """Proxy of C++ SquaredFunctionGaussianError class."""
-
+    """Proxy of C++ SquaredFunctionGaussianError class"""
     __swig_setmethods__ = {}
     for _s in [ISquaredFunction]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2328,7 +2305,7 @@ class SquaredFunctionGaussianError(ISquaredFunction):
         this = _libBornAgainFit.new_SquaredFunctionGaussianError(_self, sigma)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_SquaredFunctionGaussianError
     __del__ = lambda self: None
@@ -2363,7 +2340,6 @@ class IMinimizer(_object):
     C++ includes: IMinimizer.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, IMinimizer, name, value)
     __swig_getmethods__ = {}
@@ -2384,7 +2360,7 @@ class IMinimizer(_object):
         this = _libBornAgainFit.new_IMinimizer(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_IMinimizer
     __del__ = lambda self: None
@@ -2635,8 +2611,7 @@ IMinimizer_swigregister = _libBornAgainFit.IMinimizer_swigregister
 IMinimizer_swigregister(IMinimizer)
 
 class ChiSquaredModule(IChiSquaredModule):
-    """Proxy of C++ ChiSquaredModule class."""
-
+    """Proxy of C++ ChiSquaredModule class"""
     __swig_setmethods__ = {}
     for _s in [IChiSquaredModule]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2659,7 +2634,7 @@ class ChiSquaredModule(IChiSquaredModule):
         this = _libBornAgainFit.new_ChiSquaredModule(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_ChiSquaredModule
     __del__ = lambda self: None
@@ -2689,7 +2664,6 @@ class FitObject(libBornAgainCore.IParameterized):
     C++ includes: FitObject.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2733,7 +2707,7 @@ class FitObject(libBornAgainCore.IParameterized):
         this = _libBornAgainFit.new_FitObject(_self, simulation, real_data, weight, adjust_detector_to_data)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_FitObject
     __del__ = lambda self: None
@@ -2863,7 +2837,6 @@ class FitOptions(_object):
     C++ includes: FitOptions.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, FitOptions, name, value)
     __swig_getmethods__ = {}
@@ -2880,7 +2853,7 @@ class FitOptions(_object):
         this = _libBornAgainFit.new_FitOptions()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_FitOptions
     __del__ = lambda self: None
@@ -2936,7 +2909,6 @@ class FitParameter(libBornAgainCore.INamed, libBornAgainCore.AttLimits):
     C++ includes: FitParameter.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.INamed, libBornAgainCore.AttLimits]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -2965,7 +2937,7 @@ class FitParameter(libBornAgainCore.INamed, libBornAgainCore.AttLimits):
         this = _libBornAgainFit.new_FitParameter(_self, *args)
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_FitParameter
     __del__ = lambda self: None
@@ -3057,7 +3029,6 @@ class FitSuite(libBornAgainCore.IObservable):
     C++ includes: FitSuite.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.IObservable]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -3082,7 +3053,7 @@ class FitSuite(libBornAgainCore.IObservable):
         this = _libBornAgainFit.new_FitSuite(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
 
     def addSimulationAndRealData(self, *args):
@@ -3489,7 +3460,6 @@ class FitSuiteObjects(libBornAgainCore.IParameterized):
     C++ includes: FitSuiteObjects.h
 
     """
-
     __swig_setmethods__ = {}
     for _s in [libBornAgainCore.IParameterized]:
         __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
@@ -3514,7 +3484,7 @@ class FitSuiteObjects(libBornAgainCore.IParameterized):
         this = _libBornAgainFit.new_FitSuiteObjects(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_FitSuiteObjects
     __del__ = lambda self: None
@@ -3727,7 +3697,6 @@ class FitSuiteParameters(_object):
     C++ includes: FitSuiteParameters.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, FitSuiteParameters, name, value)
     __swig_getmethods__ = {}
@@ -3748,7 +3717,7 @@ class FitSuiteParameters(_object):
         this = _libBornAgainFit.new_FitSuiteParameters(_self, )
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_FitSuiteParameters
     __del__ = lambda self: None
@@ -4081,7 +4050,6 @@ class MinimizerFactory(_object):
     C++ includes: MinimizerFactory.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, MinimizerFactory, name, value)
     __swig_getmethods__ = {}
@@ -4123,7 +4091,7 @@ class MinimizerFactory(_object):
         this = _libBornAgainFit.new_MinimizerFactory()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_MinimizerFactory
     __del__ = lambda self: None
@@ -4154,7 +4122,6 @@ class MinimizerOptions(_object):
     C++ includes: MinimizerOptions.h
 
     """
-
     __swig_setmethods__ = {}
     __setattr__ = lambda self, name, value: _swig_setattr(self, MinimizerOptions, name, value)
     __swig_getmethods__ = {}
@@ -4171,7 +4138,7 @@ class MinimizerOptions(_object):
         this = _libBornAgainFit.new_MinimizerOptions()
         try:
             self.this.append(this)
-        except Exception:
+        except:
             self.this = this
     __swig_destroy__ = _libBornAgainFit.delete_MinimizerOptions
     __del__ = lambda self: None
@@ -4374,6 +4341,111 @@ class MinimizerOptions(_object):
 MinimizerOptions_swigregister = _libBornAgainFit.MinimizerOptions_swigregister
 MinimizerOptions_swigregister(MinimizerOptions)
 
+class FitStrategyAdjustMinimizer(IFitStrategy):
+    """
+
+
+    Strategy modifies mimimizer settings before running minimization round.
+
+    C++ includes: FitStrategyAdjustMinimizer.h
+
+    """
+    __swig_setmethods__ = {}
+    for _s in [IFitStrategy]:
+        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, FitStrategyAdjustMinimizer, name, value)
+    __swig_getmethods__ = {}
+    for _s in [IFitStrategy]:
+        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
+    __getattr__ = lambda self, name: _swig_getattr(self, FitStrategyAdjustMinimizer, name)
+    __repr__ = _swig_repr
+
+    def __init__(self, *args):
+        """
+        __init__(FitStrategyAdjustMinimizer self) -> FitStrategyAdjustMinimizer
+        __init__(FitStrategyAdjustMinimizer self, std::string const & minimizer_name, std::string const & algorithm_name, std::string const & minimizer_options) -> FitStrategyAdjustMinimizer
+        __init__(FitStrategyAdjustMinimizer self, std::string const & minimizer_name, std::string const & algorithm_name) -> FitStrategyAdjustMinimizer
+        __init__(FitStrategyAdjustMinimizer self, std::string const & minimizer_name) -> FitStrategyAdjustMinimizer
+
+        FitStrategyAdjustMinimizer::FitStrategyAdjustMinimizer(const std::string &minimizer_name, const std::string &algorithm_name=std::string(), const std::string &minimizer_options=std::string())
+
+        """
+        if self.__class__ == FitStrategyAdjustMinimizer:
+            _self = None
+        else:
+            _self = self
+        this = _libBornAgainFit.new_FitStrategyAdjustMinimizer(_self, *args)
+        try:
+            self.this.append(this)
+        except:
+            self.this = this
+    __swig_destroy__ = _libBornAgainFit.delete_FitStrategyAdjustMinimizer
+    __del__ = lambda self: None
+
+    def clone(self):
+        """
+        clone(FitStrategyAdjustMinimizer self) -> FitStrategyAdjustMinimizer
+
+        FitStrategyAdjustMinimizer * FitStrategyAdjustMinimizer::clone() const 
+
+        """
+        return _libBornAgainFit.FitStrategyAdjustMinimizer_clone(self)
+
+
+    def getMinimizer(self):
+        """
+        getMinimizer(FitStrategyAdjustMinimizer self) -> IMinimizer
+
+        IMinimizer * FitStrategyAdjustMinimizer::getMinimizer()
+
+        """
+        return _libBornAgainFit.FitStrategyAdjustMinimizer_getMinimizer(self)
+
+
+    def setMinimizer(self, *args):
+        """
+        setMinimizer(FitStrategyAdjustMinimizer self, IMinimizer minimizer)
+        setMinimizer(FitStrategyAdjustMinimizer self, std::string const & minimizer_name, std::string const & algorithm_name, std::string const & minimizer_options)
+        setMinimizer(FitStrategyAdjustMinimizer self, std::string const & minimizer_name, std::string const & algorithm_name)
+        setMinimizer(FitStrategyAdjustMinimizer self, std::string const & minimizer_name)
+
+        void FitStrategyAdjustMinimizer::setMinimizer(const std::string &minimizer_name, const std::string &algorithm_name=std::string(), const std::string &minimizer_options=std::string())
+
+        """
+        return _libBornAgainFit.FitStrategyAdjustMinimizer_setMinimizer(self, *args)
+
+
+    def execute(self):
+        """
+        execute(FitStrategyAdjustMinimizer self)
+
+        void FitStrategyAdjustMinimizer::execute()
+
+        """
+        return _libBornAgainFit.FitStrategyAdjustMinimizer_execute(self)
+
+
+    def getMinimizerOptions(self):
+        """
+        getMinimizerOptions(FitStrategyAdjustMinimizer self) -> MinimizerOptions
+
+        MinimizerOptions * FitStrategyAdjustMinimizer::getMinimizerOptions()
+
+        """
+        return _libBornAgainFit.FitStrategyAdjustMinimizer_getMinimizerOptions(self)
+
+
+    def _print(self, ostr):
+        """_print(FitStrategyAdjustMinimizer self, std::ostream & ostr)"""
+        return _libBornAgainFit.FitStrategyAdjustMinimizer__print(self, ostr)
+
+    def __disown__(self):
+        self.this.disown()
+        _libBornAgainFit.disown_FitStrategyAdjustMinimizer(self)
+        return weakref_proxy(self)
+FitStrategyAdjustMinimizer_swigregister = _libBornAgainFit.FitStrategyAdjustMinimizer_swigregister
+FitStrategyAdjustMinimizer_swigregister(FitStrategyAdjustMinimizer)
+
 # This file is compatible with both classic and new-style classes.
 
 
diff --git a/Fit/PythonAPI/libBornAgainFit_wrap.cxx b/Fit/PythonAPI/libBornAgainFit_wrap.cxx
index 4ca34e3b143eac3e3ab44529eed3c9d54c6e0591..992cf9ca362398d3bb0794bc12ccac2b538a4213 100644
--- a/Fit/PythonAPI/libBornAgainFit_wrap.cxx
+++ b/Fit/PythonAPI/libBornAgainFit_wrap.cxx
@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 3.0.8
+ * Version 3.0.7
  *
  * This file is not intended to be easily readable and contains a number of
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -8,11 +8,7 @@
  * interface file instead.
  * ----------------------------------------------------------------------------- */
 
-
-#ifndef SWIGPYTHON
 #define SWIGPYTHON
-#endif
-
 #define SWIG_DIRECTORS
 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
 
@@ -1330,7 +1326,7 @@ SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
 
 /* Unpack the argument tuple */
 
-SWIGINTERN Py_ssize_t
+SWIGINTERN int
 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
 {
   if (!args) {
@@ -1344,7 +1340,7 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssi
   }  
   if (!PyTuple_Check(args)) {
     if (min <= 1 && max >= 1) {
-      Py_ssize_t i;
+      int i;
       objs[0] = args;
       for (i = 1; i < max; ++i) {
 	objs[i] = 0;
@@ -1364,7 +1360,7 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssi
 		   name, (min == max ? "" : "at most "), (int)max, (int)l);
       return 0;
     } else {
-      Py_ssize_t i;
+      int i;
       for (i = 0; i < l; ++i) {
 	objs[i] = PyTuple_GET_ITEM(args, i);
       }
@@ -1705,32 +1701,16 @@ SwigPyObject_dealloc(PyObject *v)
     if (destroy) {
       /* destroy is always a VARARGS method */
       PyObject *res;
-
-      /* PyObject_CallFunction() has the potential to silently drop
-         the active active exception.  In cases of unnamed temporary
-         variable or where we just finished iterating over a generator
-         StopIteration will be active right now, and this needs to
-         remain true upon return from SwigPyObject_dealloc.  So save
-         and restore. */
-      
-      PyObject *val = NULL, *type = NULL, *tb = NULL;
-      PyErr_Fetch(&val, &type, &tb);
-
       if (data->delargs) {
-        /* we need to create a temporary object to carry the destroy operation */
-        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
-        res = SWIG_Python_CallFunctor(destroy, tmp);
-        Py_DECREF(tmp);
+	/* we need to create a temporary object to carry the destroy operation */
+	PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
+	res = SWIG_Python_CallFunctor(destroy, tmp);
+	Py_DECREF(tmp);
       } else {
-        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
-        PyObject *mself = PyCFunction_GET_SELF(destroy);
-        res = ((*meth)(mself, v));
+	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
+	PyObject *mself = PyCFunction_GET_SELF(destroy);
+	res = ((*meth)(mself, v));
       }
-      if (!res)
-        PyErr_WriteUnraisable(destroy);
-
-      PyErr_Restore(val, type, tb);
-
       Py_XDECREF(res);
     } 
 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
@@ -1754,7 +1734,6 @@ SwigPyObject_append(PyObject* v, PyObject* next)
   next = tmp;
 #endif
   if (!SwigPyObject_Check(next)) {
-    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
     return NULL;
   }
   sobj->next = next;
@@ -1910,9 +1889,7 @@ SwigPyObject_TypeOnce(void) {
     (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
     (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
 #endif
-#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
-#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
+#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
 #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
@@ -1992,19 +1969,10 @@ SwigPyObject_TypeOnce(void) {
       0,                                    /* tp_del */
 #endif
 #if PY_VERSION_HEX >= 0x02060000
-      0,                                    /* tp_version_tag */
-#endif
-#if PY_VERSION_HEX >= 0x03040000
-      0,                                    /* tp_finalize */
+      0,                                    /* tp_version */
 #endif
 #ifdef COUNT_ALLOCS
-      0,                                    /* tp_allocs */
-      0,                                    /* tp_frees */
-      0,                                    /* tp_maxalloc */
-#if PY_VERSION_HEX >= 0x02050000
-      0,                                    /* tp_prev */
-#endif
-      0                                     /* tp_next */
+      0,0,0,0                               /* tp_alloc -> tp_next */
 #endif
     };
     swigpyobject_type = tmp;
@@ -2180,19 +2148,10 @@ SwigPyPacked_TypeOnce(void) {
       0,                                    /* tp_del */
 #endif
 #if PY_VERSION_HEX >= 0x02060000
-      0,                                    /* tp_version_tag */
-#endif
-#if PY_VERSION_HEX >= 0x03040000
-      0,                                    /* tp_finalize */
+      0,                                    /* tp_version */
 #endif
 #ifdef COUNT_ALLOCS
-      0,                                    /* tp_allocs */
-      0,                                    /* tp_frees */
-      0,                                    /* tp_maxalloc */
-#if PY_VERSION_HEX >= 0x02050000
-      0,                                    /* tp_prev */
-#endif
-      0                                     /* tp_next */
+      0,0,0,0                               /* tp_alloc -> tp_next */
 #endif
     };
     swigpypacked_type = tmp;
@@ -2720,11 +2679,13 @@ PyModule_AddObject(PyObject *m, char *name, PyObject *o)
 {
   PyObject *dict;
   if (!PyModule_Check(m)) {
-    PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
+    PyErr_SetString(PyExc_TypeError,
+		    "PyModule_AddObject() needs module as first arg");
     return SWIG_ERROR;
   }
   if (!o) {
-    PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
+    PyErr_SetString(PyExc_TypeError,
+		    "PyModule_AddObject() needs non-NULL value");
     return SWIG_ERROR;
   }
   
@@ -3461,87 +3422,88 @@ namespace Swig {
 #define SWIGTYPE_p_FitObjects_t swig_types[4]
 #define SWIGTYPE_p_FitOptions swig_types[5]
 #define SWIGTYPE_p_FitParameter swig_types[6]
-#define SWIGTYPE_p_FitStrategyDefault swig_types[7]
-#define SWIGTYPE_p_FitSuite swig_types[8]
-#define SWIGTYPE_p_FitSuiteObjects swig_types[9]
-#define SWIGTYPE_p_FitSuiteParameters swig_types[10]
-#define SWIGTYPE_p_FitSuiteStrategies swig_types[11]
-#define SWIGTYPE_p_GISASSimulation swig_types[12]
-#define SWIGTYPE_p_IChiSquaredModule swig_types[13]
-#define SWIGTYPE_p_ICloneable swig_types[14]
-#define SWIGTYPE_p_IFitObserver swig_types[15]
-#define SWIGTYPE_p_IFitStrategy swig_types[16]
-#define SWIGTYPE_p_IHistogram swig_types[17]
-#define SWIGTYPE_p_IIntensityFunction swig_types[18]
-#define SWIGTYPE_p_IIntensityNormalizer swig_types[19]
-#define SWIGTYPE_p_IMinimizer swig_types[20]
-#define SWIGTYPE_p_INamed swig_types[21]
-#define SWIGTYPE_p_IObservable swig_types[22]
-#define SWIGTYPE_p_IObserver swig_types[23]
-#define SWIGTYPE_p_IParameterized swig_types[24]
-#define SWIGTYPE_p_ISquaredFunction swig_types[25]
-#define SWIGTYPE_p_IntensityFunctionLog swig_types[26]
-#define SWIGTYPE_p_IntensityFunctionSqrt swig_types[27]
-#define SWIGTYPE_p_IntensityNormalizer swig_types[28]
-#define SWIGTYPE_p_IntensityScaleAndShiftNormalizer swig_types[29]
-#define SWIGTYPE_p_MinimizerFactory swig_types[30]
-#define SWIGTYPE_p_MinimizerOptions swig_types[31]
-#define SWIGTYPE_p_OutputDataT_double_t swig_types[32]
-#define SWIGTYPE_p_ParameterPool swig_types[33]
-#define SWIGTYPE_p_SquaredFunctionDefault swig_types[34]
-#define SWIGTYPE_p_SquaredFunctionGaussianError swig_types[35]
-#define SWIGTYPE_p_SquaredFunctionMeanSquaredError swig_types[36]
-#define SWIGTYPE_p_SquaredFunctionSimError swig_types[37]
-#define SWIGTYPE_p_SquaredFunctionSystematicError swig_types[38]
-#define SWIGTYPE_p_allocator_type swig_types[39]
-#define SWIGTYPE_p_boost__functionT_double_fdouble_const_pF_t swig_types[40]
-#define SWIGTYPE_p_boost__functionT_double_fdouble_const_p_unsigned_int_double_pF_t swig_types[41]
-#define SWIGTYPE_p_char swig_types[42]
-#define SWIGTYPE_p_complex_t swig_types[43]
-#define SWIGTYPE_p_const_iterator swig_types[44]
-#define SWIGTYPE_p_difference_type swig_types[45]
-#define SWIGTYPE_p_double swig_types[46]
-#define SWIGTYPE_p_function_chi2_t swig_types[47]
-#define SWIGTYPE_p_function_gradient_t swig_types[48]
-#define SWIGTYPE_p_int swig_types[49]
-#define SWIGTYPE_p_iterator swig_types[50]
-#define SWIGTYPE_p_observer_t swig_types[51]
-#define SWIGTYPE_p_observerlist_t swig_types[52]
-#define SWIGTYPE_p_p_PyObject swig_types[53]
-#define SWIGTYPE_p_parameters_t swig_types[54]
-#define SWIGTYPE_p_size_type swig_types[55]
-#define SWIGTYPE_p_std__allocatorT_double_t swig_types[56]
-#define SWIGTYPE_p_std__allocatorT_int_t swig_types[57]
-#define SWIGTYPE_p_std__allocatorT_std__complexT_double_t_t swig_types[58]
-#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[59]
-#define SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[60]
-#define SWIGTYPE_p_std__allocatorT_unsigned_long_t swig_types[61]
-#define SWIGTYPE_p_std__invalid_argument swig_types[62]
-#define SWIGTYPE_p_std__ostream swig_types[63]
-#define SWIGTYPE_p_std__shared_ptrT_IFitObserver_t swig_types[64]
-#define SWIGTYPE_p_std__shared_ptrT_INamedShared_t swig_types[65]
-#define SWIGTYPE_p_std__shared_ptrT_IObserver_t swig_types[66]
-#define SWIGTYPE_p_std__shared_ptrT_IParameterizedShared_t swig_types[67]
-#define SWIGTYPE_p_std__shared_ptrT_ISampleBuilder_t swig_types[68]
-#define SWIGTYPE_p_std__shared_ptrT_LayerRTCoefficients_t_t swig_types[69]
-#define SWIGTYPE_p_std__shared_ptrT_ProgressHandler_t_t swig_types[70]
-#define SWIGTYPE_p_std__string swig_types[71]
-#define SWIGTYPE_p_std__vectorT_FitElement_std__allocatorT_FitElement_t_t swig_types[72]
-#define SWIGTYPE_p_std__vectorT_FitElement_std__allocatorT_FitElement_t_t__const_iterator swig_types[73]
-#define SWIGTYPE_p_std__vectorT_FitElement_std__allocatorT_FitElement_t_t__iterator swig_types[74]
-#define SWIGTYPE_p_std__vectorT_FitParameter_p_std__allocatorT_FitParameter_p_t_t__const_iterator swig_types[75]
-#define SWIGTYPE_p_std__vectorT_FitParameter_p_std__allocatorT_FitParameter_p_t_t__iterator swig_types[76]
-#define SWIGTYPE_p_std__vectorT_complex_t_std__allocatorT_complex_t_t_t swig_types[77]
-#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[78]
-#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[79]
-#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[80]
-#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[81]
-#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[82]
-#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[83]
-#define SWIGTYPE_p_swig__SwigPyIterator swig_types[84]
-#define SWIGTYPE_p_value_type swig_types[85]
-static swig_type_info *swig_types[87];
-static swig_module_info swig_module = {swig_types, 86, 0, 0, 0, 0};
+#define SWIGTYPE_p_FitStrategyAdjustMinimizer swig_types[7]
+#define SWIGTYPE_p_FitStrategyDefault swig_types[8]
+#define SWIGTYPE_p_FitSuite swig_types[9]
+#define SWIGTYPE_p_FitSuiteObjects swig_types[10]
+#define SWIGTYPE_p_FitSuiteParameters swig_types[11]
+#define SWIGTYPE_p_FitSuiteStrategies swig_types[12]
+#define SWIGTYPE_p_GISASSimulation swig_types[13]
+#define SWIGTYPE_p_IChiSquaredModule swig_types[14]
+#define SWIGTYPE_p_ICloneable swig_types[15]
+#define SWIGTYPE_p_IFitObserver swig_types[16]
+#define SWIGTYPE_p_IFitStrategy swig_types[17]
+#define SWIGTYPE_p_IHistogram swig_types[18]
+#define SWIGTYPE_p_IIntensityFunction swig_types[19]
+#define SWIGTYPE_p_IIntensityNormalizer swig_types[20]
+#define SWIGTYPE_p_IMinimizer swig_types[21]
+#define SWIGTYPE_p_INamed swig_types[22]
+#define SWIGTYPE_p_IObservable swig_types[23]
+#define SWIGTYPE_p_IObserver swig_types[24]
+#define SWIGTYPE_p_IParameterized swig_types[25]
+#define SWIGTYPE_p_ISquaredFunction swig_types[26]
+#define SWIGTYPE_p_IntensityFunctionLog swig_types[27]
+#define SWIGTYPE_p_IntensityFunctionSqrt swig_types[28]
+#define SWIGTYPE_p_IntensityNormalizer swig_types[29]
+#define SWIGTYPE_p_IntensityScaleAndShiftNormalizer swig_types[30]
+#define SWIGTYPE_p_MinimizerFactory swig_types[31]
+#define SWIGTYPE_p_MinimizerOptions swig_types[32]
+#define SWIGTYPE_p_OutputDataT_double_t swig_types[33]
+#define SWIGTYPE_p_ParameterPool swig_types[34]
+#define SWIGTYPE_p_SquaredFunctionDefault swig_types[35]
+#define SWIGTYPE_p_SquaredFunctionGaussianError swig_types[36]
+#define SWIGTYPE_p_SquaredFunctionMeanSquaredError swig_types[37]
+#define SWIGTYPE_p_SquaredFunctionSimError swig_types[38]
+#define SWIGTYPE_p_SquaredFunctionSystematicError swig_types[39]
+#define SWIGTYPE_p_allocator_type swig_types[40]
+#define SWIGTYPE_p_boost__functionT_double_fdouble_const_pF_t swig_types[41]
+#define SWIGTYPE_p_boost__functionT_double_fdouble_const_p_unsigned_int_double_pF_t swig_types[42]
+#define SWIGTYPE_p_char swig_types[43]
+#define SWIGTYPE_p_complex_t swig_types[44]
+#define SWIGTYPE_p_const_iterator swig_types[45]
+#define SWIGTYPE_p_difference_type swig_types[46]
+#define SWIGTYPE_p_double swig_types[47]
+#define SWIGTYPE_p_function_chi2_t swig_types[48]
+#define SWIGTYPE_p_function_gradient_t swig_types[49]
+#define SWIGTYPE_p_int swig_types[50]
+#define SWIGTYPE_p_iterator swig_types[51]
+#define SWIGTYPE_p_observer_t swig_types[52]
+#define SWIGTYPE_p_observerlist_t swig_types[53]
+#define SWIGTYPE_p_p_PyObject swig_types[54]
+#define SWIGTYPE_p_parameters_t swig_types[55]
+#define SWIGTYPE_p_size_type swig_types[56]
+#define SWIGTYPE_p_std__allocatorT_double_t swig_types[57]
+#define SWIGTYPE_p_std__allocatorT_int_t swig_types[58]
+#define SWIGTYPE_p_std__allocatorT_std__complexT_double_t_t swig_types[59]
+#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[60]
+#define SWIGTYPE_p_std__allocatorT_std__vectorT_double_std__allocatorT_double_t_t_t swig_types[61]
+#define SWIGTYPE_p_std__allocatorT_unsigned_long_t swig_types[62]
+#define SWIGTYPE_p_std__invalid_argument swig_types[63]
+#define SWIGTYPE_p_std__ostream swig_types[64]
+#define SWIGTYPE_p_std__shared_ptrT_IFitObserver_t swig_types[65]
+#define SWIGTYPE_p_std__shared_ptrT_INamedShared_t swig_types[66]
+#define SWIGTYPE_p_std__shared_ptrT_IObserver_t swig_types[67]
+#define SWIGTYPE_p_std__shared_ptrT_IParameterizedShared_t swig_types[68]
+#define SWIGTYPE_p_std__shared_ptrT_ISampleBuilder_t swig_types[69]
+#define SWIGTYPE_p_std__shared_ptrT_LayerRTCoefficients_t_t swig_types[70]
+#define SWIGTYPE_p_std__shared_ptrT_ProgressHandler_t_t swig_types[71]
+#define SWIGTYPE_p_std__string swig_types[72]
+#define SWIGTYPE_p_std__vectorT_FitElement_std__allocatorT_FitElement_t_t swig_types[73]
+#define SWIGTYPE_p_std__vectorT_FitElement_std__allocatorT_FitElement_t_t__const_iterator swig_types[74]
+#define SWIGTYPE_p_std__vectorT_FitElement_std__allocatorT_FitElement_t_t__iterator swig_types[75]
+#define SWIGTYPE_p_std__vectorT_FitParameter_p_std__allocatorT_FitParameter_p_t_t__const_iterator swig_types[76]
+#define SWIGTYPE_p_std__vectorT_FitParameter_p_std__allocatorT_FitParameter_p_t_t__iterator swig_types[77]
+#define SWIGTYPE_p_std__vectorT_complex_t_std__allocatorT_complex_t_t_t swig_types[78]
+#define SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t swig_types[79]
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[80]
+#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t swig_types[81]
+#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[82]
+#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[83]
+#define SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t swig_types[84]
+#define SWIGTYPE_p_swig__SwigPyIterator swig_types[85]
+#define SWIGTYPE_p_value_type swig_types[86]
+static swig_type_info *swig_types[88];
+static swig_module_info swig_module = {swig_types, 87, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -3565,7 +3527,7 @@ static swig_module_info swig_module = {swig_types, 86, 0, 0, 0, 0};
 #endif
 #define SWIG_name    "_libBornAgainFit"
 
-#define SWIGVERSION 0x030008 
+#define SWIGVERSION 0x030007 
 #define SWIG_VERSION SWIGVERSION
 
 
@@ -3808,11 +3770,9 @@ SWIG_AsVal_double (PyObject *obj, double *val)
   if (PyFloat_Check(obj)) {
     if (val) *val = PyFloat_AsDouble(obj);
     return SWIG_OK;
-#if PY_VERSION_HEX < 0x03000000
   } else if (PyInt_Check(obj)) {
     if (val) *val = PyInt_AsLong(obj);
     return SWIG_OK;
-#endif
   } else if (PyLong_Check(obj)) {
     double v = PyLong_AsDouble(obj);
     if (!PyErr_Occurred()) {
@@ -3904,7 +3864,18 @@ SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
       return SWIG_OK;
     } else {
       PyErr_Clear();
-      return SWIG_OverflowError;
+#if PY_VERSION_HEX >= 0x03000000
+      {
+        long v = PyLong_AsLong(obj);
+        if (!PyErr_Occurred()) {
+          if (v < 0) {
+            return SWIG_OverflowError;
+          }
+        } else {
+          PyErr_Clear();
+        }
+      }
+#endif
     }
   }
 #ifdef SWIG_PYTHON_CAST_MODE
@@ -3961,20 +3932,16 @@ SWIGINTERNINLINE PyObject*
 SWIGINTERN int
 SWIG_AsVal_long (PyObject *obj, long* val)
 {
-#if PY_VERSION_HEX < 0x03000000
   if (PyInt_Check(obj)) {
     if (val) *val = PyInt_AsLong(obj);
     return SWIG_OK;
-  } else
-#endif
-  if (PyLong_Check(obj)) {
+  } else if (PyLong_Check(obj)) {
     long v = PyLong_AsLong(obj);
     if (!PyErr_Occurred()) {
       if (val) *val = v;
       return SWIG_OK;
     } else {
       PyErr_Clear();
-      return SWIG_OverflowError;
     }
   }
 #ifdef SWIG_PYTHON_CAST_MODE
@@ -4024,7 +3991,7 @@ SWIGINTERNINLINE PyObject*
 }
 
 
-namespace swig {
+namespace swig {  
   template <class Type>
   struct noconst_traits {
     typedef Type noconst_type;
@@ -4038,7 +4005,7 @@ namespace swig {
   /*
     type categories
   */
-  struct pointer_category { };
+  struct pointer_category { };  
   struct value_category { };
 
   /*
@@ -4051,12 +4018,12 @@ namespace swig {
     return traits<typename noconst_traits<Type >::noconst_type >::type_name();
   }
 
-  template <class Type>
+  template <class Type> 
   struct traits_info {
     static swig_type_info *type_query(std::string name) {
       name += " *";
       return SWIG_TypeQuery(name.c_str());
-    }
+    }    
     static swig_type_info *type_info() {
       static swig_type_info *info = type_query(type_name<Type>());
       return info;
@@ -4077,17 +4044,17 @@ namespace swig {
       std::string ptrname = name;
       ptrname += " *";
       return ptrname;
-    }
+    }    
     static const char* type_name() {
       static std::string name = make_ptr_name(swig::type_name<Type>());
       return name.c_str();
     }
   };
 
-  template <class Type, class Category>
+  template <class Type, class Category> 
   struct traits_as { };
-
-  template <class Type, class Category>
+ 
+  template <class Type, class Category> 
   struct traits_check { };
 
 }
@@ -4431,12 +4398,6 @@ namespace swig {
     return pos;
   }
 
-  template <class Sequence>
-  inline void
-  erase(Sequence* seq, const typename Sequence::iterator& position) {
-    seq->erase(position);
-  }
-
   template <class Sequence, class Difference>
   inline Sequence*
   getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
@@ -4811,7 +4772,7 @@ namespace swig
   template <class T>
   struct SwigPySequence_Ref
   {
-    SwigPySequence_Ref(PyObject* seq, Py_ssize_t index)
+    SwigPySequence_Ref(PyObject* seq, int index)
       : _seq(seq), _index(index)
     {
     }
@@ -4823,7 +4784,7 @@ namespace swig
 	return swig::as<T>(item, true);
       } catch (std::exception& e) {
 	char msg[1024];
-	sprintf(msg, "in sequence element %d ", (int)_index);
+	sprintf(msg, "in sequence element %d ", _index);
 	if (!PyErr_Occurred()) {
 	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
 	}
@@ -4841,7 +4802,7 @@ namespace swig
 
   private:
     PyObject* _seq;
-    Py_ssize_t _index;
+    int _index;
   };
 
   template <class T>
@@ -4862,13 +4823,13 @@ namespace swig
     typedef Reference reference;
     typedef T value_type;
     typedef T* pointer;
-    typedef Py_ssize_t difference_type;
+    typedef int difference_type;
 
     SwigPySequence_InputIterator()
     {
     }
 
-    SwigPySequence_InputIterator(PyObject* seq, Py_ssize_t index)
+    SwigPySequence_InputIterator(PyObject* seq, int index)
       : _seq(seq), _index(index)
     {
     }
@@ -4948,7 +4909,6 @@ namespace swig
     difference_type _index;
   };
 
-  // STL container wrapper around a Python sequence
   template <class T>
   struct SwigPySequence_Cont
   {
@@ -4956,8 +4916,8 @@ namespace swig
     typedef const SwigPySequence_Ref<T> const_reference;
     typedef T value_type;
     typedef T* pointer;
-    typedef Py_ssize_t difference_type;
-    typedef size_t size_type;
+    typedef int difference_type;
+    typedef int size_type;
     typedef const pointer const_pointer;
     typedef SwigPySequence_InputIterator<T, reference> iterator;
     typedef SwigPySequence_InputIterator<T, const_reference> const_iterator;
@@ -5018,13 +4978,13 @@ namespace swig
 
     bool check(bool set_err = true) const
     {
-      Py_ssize_t s = size();
-      for (Py_ssize_t i = 0; i < s; ++i) {
+      int s = size();
+      for (int i = 0; i < s; ++i) {
 	swig::SwigVar_PyObject item = PySequence_GetItem(_seq, i);
 	if (!swig::check<value_type>(item)) {
 	  if (set_err) {
 	    char msg[1024];
-	    sprintf(msg, "in sequence element %d", (int)i);
+	    sprintf(msg, "in sequence element %d", i);
 	    SWIG_Error(SWIG_RuntimeError, msg);
 	  }
 	  return false;
@@ -5044,17 +5004,17 @@ namespace swig
 
 
 namespace swig {
-  template <> struct traits< double > {
+  template <> struct traits<double > {
     typedef value_category category;
     static const char* type_name() { return"double"; }
-  };
-  template <>  struct traits_asval< double > {
+  };  
+  template <>  struct traits_asval<double > {   
     typedef double value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_double (obj, val);
     }
   };
-  template <>  struct traits_from< double > {
+  template <>  struct traits_from<double > {
     typedef double value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_double  (val);
@@ -5128,9 +5088,10 @@ namespace swig {
 #endif
       size_type size = seq.size();
       if (size <= (size_type)INT_MAX) {
-	PyObject *obj = PyTuple_New((Py_ssize_t)size);
-	Py_ssize_t i = 0;
-	for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) {
+	PyObject *obj = PyTuple_New((int)size);
+	int i = 0;
+	for (const_iterator it = seq.begin();
+	     it != seq.end(); ++it, ++i) {
 	  PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
 	}
 	return obj;
@@ -5161,7 +5122,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< double, std::allocator< double > > > {
+	template <>  struct traits<std::vector<double, std::allocator< double > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "double" "," "std::allocator< double >" " >";
@@ -5196,20 +5157,24 @@ SWIG_From_size_t  (size_t value)
   return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
 }
 
+SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<double,std::allocator< double > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
-    }
-SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
+SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v=std::vector< double,std::allocator< double > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5218,8 +5183,8 @@ SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< double,std::allocator< double > >::difference_type id = i;
-      std::vector< double,std::allocator< double > >::difference_type jd = j;
+      std::vector<double,std::allocator< double > >::difference_type id = i;
+      std::vector<double,std::allocator< double > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,PySliceObject *slice,std::vector< double,std::allocator< double > > const &v){
@@ -5229,8 +5194,8 @@ SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< double,std::allocator< double > >::difference_type id = i;
-      std::vector< double,std::allocator< double > >::difference_type jd = j;
+      std::vector<double,std::allocator< double > >::difference_type id = i;
+      std::vector<double,std::allocator< double > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
@@ -5240,8 +5205,8 @@ SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< double,std::allocator< double > >::difference_type id = i;
-      std::vector< double,std::allocator< double > >::difference_type jd = j;
+      std::vector<double,std::allocator< double > >::difference_type id = i;
+      std::vector<double,std::allocator< double > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,PySliceObject *slice){
@@ -5251,8 +5216,8 @@ SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< double,std::allocator< double > >::difference_type id = i;
-      std::vector< double,std::allocator< double > >::difference_type jd = j;
+      std::vector<double,std::allocator< double > >::difference_type id = i;
+      std::vector<double,std::allocator< double > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
@@ -5261,13 +5226,6 @@ SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____g
 SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< double,std::allocator< double > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
       self->push_back(x);
     }
@@ -5277,7 +5235,7 @@ SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG
 SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }
 
       namespace swig {
-	template <>  struct traits<std::vector< std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
+	template <>  struct traits<std::vector<std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "std::vector< double,std::allocator< double > >" "," "std::allocator< std::vector< double,std::allocator< double > > >" " >";
@@ -5297,20 +5255,24 @@ SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____bool__(std::vector<
 SWIGINTERN std::vector< std::vector< double > >::size_type std_vector_Sl_std_vector_Sl_double_Sg__Sg____len__(std::vector< std::vector< double > > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< std::vector< double > >::value_type std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 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____getslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >());
-    }
-SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____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){
+SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(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=std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 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____getitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5319,8 +5281,8 @@ SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allo
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,PySliceObject *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
@@ -5330,8 +5292,8 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(s
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
@@ -5341,8 +5303,8 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(s
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,PySliceObject *slice){
@@ -5352,8 +5314,8 @@ SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(s
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
+      std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< std::vector< double > >::value_type const &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){
@@ -5362,13 +5324,6 @@ SWIGINTERN std::vector< std::vector< double > >::value_type const &std_vector_Sl
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< std::vector< double > >::value_type std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__append(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::value_type const &x){
       self->push_back(x);
     }
@@ -5404,17 +5359,17 @@ SWIG_AsVal_int (PyObject * obj, int *val)
 
 
 namespace swig {
-  template <> struct traits< int > {
+  template <> struct traits<int > {
     typedef value_category category;
     static const char* type_name() { return"int"; }
-  };
-  template <>  struct traits_asval< int > {
+  };  
+  template <>  struct traits_asval<int > {   
     typedef int value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_int (obj, val);
     }
   };
-  template <>  struct traits_from< int > {
+  template <>  struct traits_from<int > {
     typedef int value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_int  (val);
@@ -5424,7 +5379,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< int, std::allocator< int > > > {
+	template <>  struct traits<std::vector<int, std::allocator< int > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "int" "," "std::allocator< int >" " >";
@@ -5444,20 +5399,24 @@ SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
 SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<int,std::allocator< int > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
-    }
-SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
+SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v=std::vector< int,std::allocator< int > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5466,8 +5425,8 @@ SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____get
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< int,std::allocator< int > >::difference_type id = i;
-      std::vector< int,std::allocator< int > >::difference_type jd = j;
+      std::vector<int,std::allocator< int > >::difference_type id = i;
+      std::vector<int,std::allocator< int > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,PySliceObject *slice,std::vector< int,std::allocator< int > > const &v){
@@ -5477,8 +5436,8 @@ SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *se
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< int,std::allocator< int > >::difference_type id = i;
-      std::vector< int,std::allocator< int > >::difference_type jd = j;
+      std::vector<int,std::allocator< int > >::difference_type id = i;
+      std::vector<int,std::allocator< int > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
@@ -5488,8 +5447,8 @@ SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *se
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< int,std::allocator< int > >::difference_type id = i;
-      std::vector< int,std::allocator< int > >::difference_type jd = j;
+      std::vector<int,std::allocator< int > >::difference_type id = i;
+      std::vector<int,std::allocator< int > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,PySliceObject *slice){
@@ -5499,8 +5458,8 @@ SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *se
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< int,std::allocator< int > >::difference_type id = i;
-      std::vector< int,std::allocator< int > >::difference_type jd = j;
+      std::vector<int,std::allocator< int > >::difference_type id = i;
+      std::vector<int,std::allocator< int > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem____SWIG_1(std::vector< int > const *self,std::vector< int >::difference_type i){
@@ -5509,13 +5468,6 @@ SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem
 SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_2(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< int,std::allocator< int > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
       self->push_back(x);
     }
@@ -5525,17 +5477,17 @@ SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__insert__SWIG_0(std
 SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::size_type n,std::vector< int >::value_type const &x){ self->insert(pos, n, x); }
 
 namespace swig {
-  template <> struct traits< unsigned long > {
+  template <> struct traits<unsigned long > {
     typedef value_category category;
     static const char* type_name() { return"unsigned long"; }
-  };
-  template <>  struct traits_asval< unsigned long > {
+  };  
+  template <>  struct traits_asval<unsigned long > {   
     typedef unsigned long value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_unsigned_SS_long (obj, val);
     }
   };
-  template <>  struct traits_from< unsigned long > {
+  template <>  struct traits_from<unsigned long > {
     typedef unsigned long value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_unsigned_SS_long  (val);
@@ -5545,7 +5497,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< unsigned long, std::allocator< unsigned long > > > {
+	template <>  struct traits<std::vector<unsigned long, std::allocator< unsigned long > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "unsigned long" "," "std::allocator< unsigned long >" " >";
@@ -5565,20 +5517,24 @@ SWIGINTERN bool std_vector_Sl_unsigned_SS_long_Sg____bool__(std::vector< unsigne
 SWIGINTERN std::vector< unsigned long >::size_type std_vector_Sl_unsigned_SS_long_Sg____len__(std::vector< unsigned long > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< unsigned long >::value_type std_vector_Sl_unsigned_SS_long_Sg__pop(std::vector< unsigned long > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<unsigned long,std::allocator< unsigned long > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getslice__(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< unsigned long,std::allocator< unsigned long > >());
-    }
-SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_1(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
+SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j,std::vector< unsigned long,std::allocator< unsigned long > > const &v=std::vector< unsigned long,std::allocator< unsigned long > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delslice__(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_0(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5587,8 +5543,8 @@ SWIGINTERN std::vector< unsigned long,std::allocator< unsigned long > > *std_vec
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type id = i;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vector< unsigned long > *self,PySliceObject *slice,std::vector< unsigned long,std::allocator< unsigned long > > const &v){
@@ -5598,8 +5554,8 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_0(std::vect
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type id = i;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
@@ -5609,8 +5565,8 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_1(std::vect
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type id = i;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vector< unsigned long > *self,PySliceObject *slice){
@@ -5620,8 +5576,8 @@ SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____delitem____SWIG_1(std::vect
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type id = i;
-      std::vector< unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type id = i;
+      std::vector<unsigned long,std::allocator< unsigned long > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< unsigned long >::value_type const &std_vector_Sl_unsigned_SS_long_Sg____getitem____SWIG_1(std::vector< unsigned long > const *self,std::vector< unsigned long >::difference_type i){
@@ -5630,13 +5586,6 @@ SWIGINTERN std::vector< unsigned long >::value_type const &std_vector_Sl_unsigne
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg____setitem____SWIG_2(std::vector< unsigned long > *self,std::vector< unsigned long >::difference_type i,std::vector< unsigned long >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< unsigned long >::value_type std_vector_Sl_unsigned_SS_long_Sg__pop(std::vector< unsigned long > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< unsigned long,std::allocator< unsigned long > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_unsigned_SS_long_Sg__append(std::vector< unsigned long > *self,std::vector< unsigned long >::value_type const &x){
       self->push_back(x);
     }
@@ -5664,7 +5613,7 @@ SWIG_AsVal_std_complex_Sl_double_Sg_  (PyObject *o, std::complex<double>* val)
 
 
 SWIGINTERNINLINE PyObject*
-SWIG_From_std_complex_Sl_double_Sg_  (/*@SWIG:/usr/share/swig3.0/typemaps/swigmacros.swg,104,%ifcplusplus@*/
+SWIG_From_std_complex_Sl_double_Sg_  (/*@SWIG:/usr/share/swig/3.0.7/typemaps/swigmacros.swg,104,%ifcplusplus@*/
 
 const std::complex<double>&
 
@@ -5677,17 +5626,17 @@ const std::complex<double>&
 
 
 namespace swig {
-  template <> struct traits< std::complex<double> > {
+  template <> struct traits<std::complex<double> > {
     typedef value_category category;
     static const char* type_name() { return"std::complex<double>"; }
-  };
-  template <>  struct traits_asval< std::complex<double> > {
+  };  
+  template <>  struct traits_asval<std::complex<double> > {   
     typedef std::complex<double> value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_std_complex_Sl_double_Sg_ (obj, val);
     }
   };
-  template <>  struct traits_from< std::complex<double> > {
+  template <>  struct traits_from<std::complex<double> > {
     typedef std::complex<double> value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_std_complex_Sl_double_Sg_  (val);
@@ -5697,7 +5646,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< std::complex< double >, std::allocator< std::complex< double > > > > {
+	template <>  struct traits<std::vector<std::complex< double >, std::allocator< std::complex< double > > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "std::complex< double >" "," "std::allocator< std::complex< double > >" " >";
@@ -5717,20 +5666,24 @@ SWIGINTERN bool std_vector_Sl_std_complex_Sl_double_Sg__Sg____bool__(std::vector
 SWIGINTERN std::vector< std::complex< double > >::size_type std_vector_Sl_std_complex_Sl_double_Sg__Sg____len__(std::vector< std::complex< double > > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< std::complex< double > >::value_type std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(std::vector< std::complex< double > > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getslice__(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< std::complex< double >,std::allocator< std::complex< double > > >());
-    }
-SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
+SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v=std::vector< std::complex< double >,std::allocator< std::complex< double > > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delslice__(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< double > > > *std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -5739,8 +5692,8 @@ SWIGINTERN std::vector< std::complex< double >,std::allocator< std::complex< dou
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::complex< double > > *self,PySliceObject *slice,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &v){
@@ -5750,8 +5703,8 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_0(
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
@@ -5761,8 +5714,8 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_1(
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::complex< double > > *self,PySliceObject *slice){
@@ -5772,8 +5725,8 @@ SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____delitem____SWIG_1(
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type id = i;
+      std::vector<std::complex< double >,std::allocator< std::complex< double > > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< std::complex< double > >::value_type const &std_vector_Sl_std_complex_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::complex< double > > const *self,std::vector< std::complex< double > >::difference_type i){
@@ -5782,13 +5735,6 @@ SWIGINTERN std::vector< std::complex< double > >::value_type const &std_vector_S
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::difference_type i,std::vector< std::complex< double > >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< std::complex< double > >::value_type std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(std::vector< std::complex< double > > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< std::complex< double >,std::allocator< std::complex< double > > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_std_complex_Sl_double_Sg__Sg__append(std::vector< std::complex< double > > *self,std::vector< std::complex< double > >::value_type const &x){
       self->push_back(x);
     }
@@ -5850,17 +5796,18 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
 #else
 	if (*alloc == SWIG_NEWOBJ) 
 #endif
-	{
-	  *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
-	  *alloc = SWIG_NEWOBJ;
-	} else {
+	  {
+	    *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
+	    *alloc = SWIG_NEWOBJ;
+	  }
+	else {
 	  *cptr = cstr;
 	  *alloc = SWIG_OLDOBJ;
 	}
       } else {
-	#if PY_VERSION_HEX>=0x03000000
-	assert(0); /* Should never reach here in Python 3 */
-	#endif
+        #if PY_VERSION_HEX>=0x03000000
+        assert(0); /* Should never reach here in Python 3 */
+        #endif
 	*cptr = SWIG_Python_str_AsChar(obj);
       }
     }
@@ -5870,30 +5817,6 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
 #endif
     return SWIG_OK;
   } else {
-#if defined(SWIG_PYTHON_2_UNICODE)
-#if PY_VERSION_HEX<0x03000000
-    if (PyUnicode_Check(obj)) {
-      char *cstr; Py_ssize_t len;
-      if (!alloc && cptr) {
-        return SWIG_RuntimeError;
-      }
-      obj = PyUnicode_AsUTF8String(obj);
-      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
-        if (cptr) {
-          if (alloc) *alloc = SWIG_NEWOBJ;
-          *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
-        }
-        if (psize) *psize = len + 1;
-
-        Py_XDECREF(obj);
-        return SWIG_OK;
-      } else {
-        Py_XDECREF(obj);
-      }
-    }
-#endif
-#endif
-
     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
     if (pchar_descriptor) {
       void* vptr = 0;
@@ -5969,12 +5892,12 @@ SWIG_FromCharPtrAndSize(const char* carray, size_t size)
     } else {
 #if PY_VERSION_HEX >= 0x03000000
 #if PY_VERSION_HEX >= 0x03010000
-      return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
+      return PyUnicode_DecodeUTF8(carray, static_cast< int >(size), "surrogateescape");
 #else
-      return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
+      return PyUnicode_FromStringAndSize(carray, static_cast< int >(size));
 #endif
 #else
-      return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
+      return PyString_FromStringAndSize(carray, static_cast< int >(size));
 #endif
     }
   } else {
@@ -5991,17 +5914,17 @@ SWIG_From_std_string  (const std::string& s)
 
 
 namespace swig {
-  template <> struct traits< std::string > {
+  template <> struct traits<std::string > {
     typedef value_category category;
     static const char* type_name() { return"std::string"; }
-  };
-  template <>  struct traits_asval< std::string > {
+  };  
+  template <>  struct traits_asval<std::string > {   
     typedef std::string value_type;
-    static int asval(PyObject *obj, value_type *val) {
+    static int asval(PyObject *obj, value_type *val) { 
       return SWIG_AsVal_std_string (obj, val);
     }
   };
-  template <>  struct traits_from< std::string > {
+  template <>  struct traits_from<std::string > {
     typedef std::string value_type;
     static PyObject *from(const value_type& val) {
       return SWIG_From_std_string  (val);
@@ -6011,7 +5934,7 @@ namespace swig {
 
 
       namespace swig {
-	template <>  struct traits<std::vector< std::string, std::allocator< std::string > > > {
+	template <>  struct traits<std::vector<std::string, std::allocator< std::string > > > {
 	  typedef pointer_category category;
 	  static const char* type_name() {
 	    return "std::vector<" "std::string" "," "std::allocator< std::string >" " >";
@@ -6031,20 +5954,24 @@ SWIGINTERN bool std_vector_Sl_std_string_Sg____bool__(std::vector< std::string >
 SWIGINTERN std::vector< std::string >::size_type std_vector_Sl_std_string_Sg____len__(std::vector< std::string > const *self){
       return self->size();
     }
+SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
+      if (self->size() == 0)
+	throw std::out_of_range("pop from empty container");
+      std::vector<std::string,std::allocator< std::string > >::value_type x = self->back();
+      self->pop_back();
+      return x;
+    }
 SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
       return swig::getslice(self, i, j, 1);
     }
-SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
-      swig::setslice(self, i, j, 1, std::vector< std::string,std::allocator< std::string > >());
-    }
-SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_1(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j,std::vector< std::string,std::allocator< std::string > > const &v){
+SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j,std::vector< std::string,std::allocator< std::string > > const &v=std::vector< std::string,std::allocator< std::string > >()){
       swig::setslice(self, i, j, 1, v);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
       swig::delslice(self, i, j, 1);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
-      swig::erase(self, swig::getpos(self, i));
+      self->erase(swig::getpos(self,i));
     }
 SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice){
       Py_ssize_t i, j, step;
@@ -6053,8 +5980,8 @@ SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_
         return NULL;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
-      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
+      std::vector<std::string,std::allocator< std::string > >::difference_type id = i;
+      std::vector<std::string,std::allocator< std::string > >::difference_type jd = j;
       return swig::getslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,PySliceObject *slice,std::vector< std::string,std::allocator< std::string > > const &v){
@@ -6064,8 +5991,8 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< st
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
-      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
+      std::vector<std::string,std::allocator< std::string > >::difference_type id = i;
+      std::vector<std::string,std::allocator< std::string > >::difference_type jd = j;
       swig::setslice(self, id, jd, step, v);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
@@ -6075,8 +6002,8 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< st
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
-      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
+      std::vector<std::string,std::allocator< std::string > >::difference_type id = i;
+      std::vector<std::string,std::allocator< std::string > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,PySliceObject *slice){
@@ -6086,8 +6013,8 @@ SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< st
         return;
       }
       PySlice_GetIndices(SWIGPY_SLICE_ARG(slice), (Py_ssize_t)self->size(), &i, &j, &step);
-      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
-      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
+      std::vector<std::string,std::allocator< std::string > >::difference_type id = i;
+      std::vector<std::string,std::allocator< std::string > >::difference_type jd = j;
       swig::delslice(self, id, jd, step);
     }
 SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_string_Sg____getitem____SWIG_1(std::vector< std::string > const *self,std::vector< std::string >::difference_type i){
@@ -6096,13 +6023,6 @@ SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_strin
 SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_2(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
-      if (self->size() == 0)
-	throw std::out_of_range("pop from empty container");
-      std::vector< std::string,std::allocator< std::string > >::value_type x = self->back();
-      self->pop_back();
-      return x;
-    }
 SWIGINTERN void std_vector_Sl_std_string_Sg__append(std::vector< std::string > *self,std::vector< std::string >::value_type const &x){
       self->push_back(x);
     }
@@ -6144,6 +6064,7 @@ SWIGINTERN void std_vector_Sl_std_string_Sg__insert__SWIG_1(std::vector< std::st
 #include "MathFunctions.h"
 #include "MinimizerFactory.h"
 #include "MinimizerOptions.h"
+#include "FitStrategyAdjustMinimizer.h"
 
 
 
@@ -8468,7 +8389,7 @@ std::vector< double,std::allocator< double > > SwigDirector_IMinimizer::getValue
       Swig::DirectorMethodException::raise("Error detected when calling 'IMinimizer.getValueOfVariablesAtMinimum'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -8529,7 +8450,7 @@ std::vector< double,std::allocator< double > > SwigDirector_IMinimizer::getError
       Swig::DirectorMethodException::raise("Error detected when calling 'IMinimizer.getErrorOfVariables'");
     }
   }
-  std::vector< double,std::allocator< double > > *swig_optr = 0;
+  std::vector<double,std::allocator< double > > *swig_optr = 0;
   int swig_ores = swig::asptr(result, &swig_optr);
   if (!SWIG_IsOK(swig_ores) || !swig_optr) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError((swig_optr ? swig_ores : SWIG_TypeError))), "in output value of type '""std::vector< double,std::allocator< double > >""'");
@@ -9478,6 +9399,158 @@ SwigDirector_FitSuiteParameters::SwigDirector_FitSuiteParameters(PyObject *self)
 SwigDirector_FitSuiteParameters::~SwigDirector_FitSuiteParameters() {
 }
 
+SwigDirector_FitStrategyAdjustMinimizer::SwigDirector_FitStrategyAdjustMinimizer(PyObject *self): FitStrategyAdjustMinimizer(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((FitStrategyAdjustMinimizer *)this, this); 
+}
+
+
+
+
+SwigDirector_FitStrategyAdjustMinimizer::SwigDirector_FitStrategyAdjustMinimizer(PyObject *self, std::string const &minimizer_name, std::string const &algorithm_name, std::string const &minimizer_options): FitStrategyAdjustMinimizer(minimizer_name, algorithm_name, minimizer_options), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((FitStrategyAdjustMinimizer *)this, this); 
+}
+
+
+
+
+SwigDirector_FitStrategyAdjustMinimizer::~SwigDirector_FitStrategyAdjustMinimizer() {
+}
+
+FitStrategyAdjustMinimizer *SwigDirector_FitStrategyAdjustMinimizer::clone() const {
+  void *swig_argp ;
+  int swig_res ;
+  swig_owntype own ;
+  
+  FitStrategyAdjustMinimizer *c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FitStrategyAdjustMinimizer.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 0;
+  const char * const swig_method_name = "clone";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "clone", NULL);
+#endif
+  if (!result) {
+    PyObject *error = PyErr_Occurred();
+    if (error) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'FitStrategyAdjustMinimizer.clone'");
+    }
+  }
+  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_FitStrategyAdjustMinimizer,  0  | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""FitStrategyAdjustMinimizer *""'");
+  }
+  c_result = reinterpret_cast< FitStrategyAdjustMinimizer * >(swig_argp);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
+  return (FitStrategyAdjustMinimizer *) c_result;
+}
+
+
+void SwigDirector_FitStrategyAdjustMinimizer::init(FitKernel *fit_suite) {
+  swig::SwigVar_PyObject obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(fit_suite), SWIGTYPE_p_FitKernel,  0 );
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FitStrategyAdjustMinimizer.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 1;
+  const char * const swig_method_name = "init";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"init", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  if (!result) {
+    PyObject *error = PyErr_Occurred();
+    if (error) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'FitStrategyAdjustMinimizer.init'");
+    }
+  }
+}
+
+
+void SwigDirector_FitStrategyAdjustMinimizer::execute() {
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FitStrategyAdjustMinimizer.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 2;
+  const char * const swig_method_name = "execute";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "execute", NULL);
+#endif
+  if (!result) {
+    PyObject *error = PyErr_Occurred();
+    if (error) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'FitStrategyAdjustMinimizer.execute'");
+    }
+  }
+}
+
+
+void SwigDirector_FitStrategyAdjustMinimizer::print(std::ostream &ostr) const {
+  swig::SwigVar_PyObject obj0;
+  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&ostr), SWIGTYPE_p_std__ostream,  0 );
+  swig_set_inner("print", true);
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FitStrategyAdjustMinimizer.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 3;
+  const char * const swig_method_name = "_print";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::SwigVar_PyObject result = PyObject_CallFunction(method, (char *)"(O)" ,(PyObject *)obj0);
+#else
+  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *)"_print", (char *)"(O)" ,(PyObject *)obj0);
+#endif
+  swig_set_inner("print", false);
+  if (!result) {
+    PyObject *error = PyErr_Occurred();
+    if (error) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'FitStrategyAdjustMinimizer._print'");
+    }
+  }
+}
+
+
+MinimizerOptions *SwigDirector_FitStrategyAdjustMinimizer::getMinimizerOptions() {
+  void *swig_argp ;
+  int swig_res ;
+  swig_owntype own ;
+  
+  MinimizerOptions *c_result;
+  if (!swig_get_self()) {
+    Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call FitStrategyAdjustMinimizer.__init__.");
+  }
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+  const size_t swig_method_index = 4;
+  const char * const swig_method_name = "getMinimizerOptions";
+  PyObject* method = swig_get_method(swig_method_index, swig_method_name);
+  swig::SwigVar_PyObject result = PyObject_CallFunction(method, NULL, NULL);
+#else
+  swig::SwigVar_PyObject result = PyObject_CallMethod(swig_get_self(), (char *) "getMinimizerOptions", NULL);
+#endif
+  if (!result) {
+    PyObject *error = PyErr_Occurred();
+    if (error) {
+      Swig::DirectorMethodException::raise("Error detected when calling 'FitStrategyAdjustMinimizer.getMinimizerOptions'");
+    }
+  }
+  swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_MinimizerOptions,  0  | SWIG_POINTER_DISOWN, &own);
+  if (!SWIG_IsOK(swig_res)) {
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""MinimizerOptions *""'");
+  }
+  c_result = reinterpret_cast< MinimizerOptions * >(swig_argp);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
+  return (MinimizerOptions *) c_result;
+}
+
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -9608,14 +9681,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -9727,14 +9800,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -10278,14 +10351,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -10432,6 +10505,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble1d_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< double >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_pop" "', argument " "1"" of type '" "std::vector< double > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+  try {
+    result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_double(static_cast< double >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble1d_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -10486,17 +10587,20 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_0(PyObject *SWIGUNUSED
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
   std::vector< double >::difference_type arg2 ;
   std::vector< double >::difference_type arg3 ;
+  std::vector< double,std::allocator< double > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOO:vdouble1d_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vdouble1d_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
@@ -10512,8 +10616,19 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_0(PyObject *SWIGUNUSED
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vdouble1d_t___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< double >::difference_type >(val3);
+  {
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vdouble1d_t___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vdouble1d_t___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
   try {
-    std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,arg2,arg3);
+    std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -10523,8 +10638,10 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_0(PyObject *SWIGUNUSED
   }
   
   resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
@@ -10534,20 +10651,17 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_1(PyObject *SWIGUNUSED
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
   std::vector< double >::difference_type arg2 ;
   std::vector< double >::difference_type arg3 ;
-  std::vector< double,std::allocator< double > > *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
   ptrdiff_t val3 ;
   int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
   
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vdouble1d_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  if (!PyArg_ParseTuple(args,(char *)"OOO:vdouble1d_t___setslice__",&obj0,&obj1,&obj2)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
@@ -10563,19 +10677,8 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_1(PyObject *SWIGUNUSED
     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vdouble1d_t___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
   } 
   arg3 = static_cast< std::vector< double >::difference_type >(val3);
-  {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vdouble1d_t___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vdouble1d_t___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
   try {
-    std_vector_Sl_double_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< double,std::allocator< double > > const &)*arg4);
+    std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,arg2,arg3);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -10585,29 +10688,27 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice____SWIG_1(PyObject *SWIGUNUSED
   }
   
   resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return resultobj;
 fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -10620,14 +10721,14 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice__(PyObject *self, PyObject *ar
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vdouble1d_t___setslice____SWIG_0(self, args);
+          return _wrap_vdouble1d_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -10640,10 +10741,10 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice__(PyObject *self, PyObject *ar
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<double,std::allocator< double > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vdouble1d_t___setslice____SWIG_1(self, args);
+            return _wrap_vdouble1d_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -10653,8 +10754,8 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setslice__(PyObject *self, PyObject *ar
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vdouble1d_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type)\n"
-    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type,std::vector< double,std::allocator< double > > const &)\n");
+    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type,std::vector< double,std::allocator< double > > const &)\n"
+    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type)\n");
   return 0;
 }
 
@@ -10735,9 +10836,6 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem____SWIG_0(PyObject *SWIGUNUSEDP
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -10810,7 +10908,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem____SWIG_0(PyObject *SWIGUNUSEDP
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble1d_t___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -10916,20 +11014,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -10942,7 +11040,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___delitem__(PyObject *self, PyObject *arg
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11002,20 +11100,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11028,7 +11126,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___getitem__(PyObject *self, PyObject *arg
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11098,20 +11196,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11124,14 +11222,14 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble1d_t___setitem____SWIG_0(self, args);
@@ -11141,7 +11239,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t___setitem__(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11170,34 +11268,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< double >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_pop" "', argument " "1"" of type '" "std::vector< double > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  try {
-    result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_From_double(static_cast< double >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vdouble1d_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -11252,7 +11322,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble1d_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vdouble1d_t",&obj0)) SWIG_fail;
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vdouble1d_t" "', argument " "1"" of type '" "std::vector< double > const &""'"); 
@@ -11316,6 +11386,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble1d_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_clear" "', argument " "1"" of type '" "std::vector< double > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble1d_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -11349,6 +11440,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble1d_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< double > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
+  result = ((std::vector< double > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble1d_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double > *arg1 = (std::vector< double > *) 0 ;
@@ -11441,49 +11554,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble1d_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_clear" "', argument " "1"" of type '" "std::vector< double > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vdouble1d_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< double > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble1d_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_std__allocatorT_double_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble1d_t_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
-  result = ((std::vector< double > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(static_cast< const std::vector< double >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vdouble1d_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< double >::size_type arg1 ;
@@ -11649,20 +11719,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -11675,7 +11745,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t_erase(PyObject *self, PyObject *args) {
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -11735,14 +11805,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vdouble1d_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -11761,7 +11831,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble1d_t(PyObject *self, PyObject *args) {
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vdouble1d_t__SWIG_1(self, args);
@@ -11954,20 +12024,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11981,7 +12051,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t_resize(PyObject *self, PyObject *args) {
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -12115,20 +12185,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble1d_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -12147,7 +12217,7 @@ SWIGINTERN PyObject *_wrap_vdouble1d_t_insert(PyObject *self, PyObject *args) {
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -12350,6 +12420,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble2d_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< std::vector< double > >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &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 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_pop" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
+  try {
+    result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble2d_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
@@ -12400,6 +12498,70 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
+  std::vector< std::vector< double > >::difference_type arg2 ;
+  std::vector< std::vector< double > >::difference_type arg3 ;
+  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vdouble2d_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &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 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vdouble2d_t___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vdouble2d_t___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
+  {
+    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;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vdouble2d_t___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vdouble2d_t___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  try {
+    std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg4);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
   std::vector< std::vector< double > >::difference_type arg2 ;
@@ -12447,85 +12609,21 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
-  std::vector< std::vector< double > >::difference_type arg2 ;
-  std::vector< std::vector< double > >::difference_type arg3 ;
-  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg4 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  ptrdiff_t val3 ;
-  int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vdouble2d_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &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 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vdouble2d_t___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
-  } 
-  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
-  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vdouble2d_t___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::difference_type""'");
-  } 
-  arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
-  {
-    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;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vdouble2d_t___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vdouble2d_t___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
-  try {
-    std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg4);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return resultobj;
-fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -12538,14 +12636,14 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice__(PyObject *self, PyObject *ar
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vdouble2d_t___setslice____SWIG_0(self, args);
+          return _wrap_vdouble2d_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -12558,10 +12656,10 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice__(PyObject *self, PyObject *ar
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vdouble2d_t___setslice____SWIG_1(self, args);
+            return _wrap_vdouble2d_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -12571,8 +12669,8 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setslice__(PyObject *self, PyObject *ar
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vdouble2d_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< std::vector< double > >::__setslice__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::difference_type)\n"
-    "    std::vector< std::vector< double > >::__setslice__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n");
+    "    std::vector< std::vector< double > >::__setslice__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
+    "    std::vector< std::vector< double > >::__setslice__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::difference_type)\n");
   return 0;
 }
 
@@ -12653,9 +12751,6 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem____SWIG_0(PyObject *SWIGUNUSEDP
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -12728,7 +12823,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_0(PyObject *SWIGUNUSEDP
     arg2 = (PySliceObject *) obj1;
   }
   {
-    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;
+    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;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
@@ -12834,20 +12929,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -12860,7 +12955,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___delitem__(PyObject *self, PyObject *arg
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -12912,7 +13007,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem____SWIG_1(PyObject *SWIGUNUSEDP
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
   
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(*result));
   return resultobj;
 fail:
   return NULL;
@@ -12920,20 +13015,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -12946,7 +13041,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___getitem__(PyObject *self, PyObject *arg
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -12994,7 +13089,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem____SWIG_2(PyObject *SWIGUNUSEDP
   } 
   arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -13021,20 +13116,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -13047,14 +13142,14 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble2d_t___setitem____SWIG_0(self, args);
@@ -13064,7 +13159,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -13072,7 +13167,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t___setitem__(PyObject *self, PyObject *arg
         _v = SWIG_CheckState(res);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble2d_t___setitem____SWIG_2(self, args);
@@ -13091,34 +13186,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble2d_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< std::vector< double > >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &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 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_pop" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
-  try {
-    result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vdouble2d_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
@@ -13136,7 +13203,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_append(PyObject *SWIGUNUSEDPARM(self), Py
   }
   arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vdouble2d_t_append" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -13178,7 +13245,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble2d_t__SWIG_1(PyObject *SWIGUNUSEDPARM(self
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vdouble2d_t",&obj0)) SWIG_fail;
   {
-    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;
+    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;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vdouble2d_t" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const &""'"); 
@@ -13242,6 +13309,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble2d_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &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 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_clear" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble2d_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
@@ -13275,6 +13363,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vdouble2d_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< std::vector< double,std::allocator< double > > > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &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 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
+  result = ((std::vector< std::vector< double > > const *)arg1)->get_allocator();
+  resultobj = 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 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vdouble2d_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
@@ -13367,49 +13477,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vdouble2d_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &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 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_clear" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vdouble2d_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::vector< double > > *arg1 = (std::vector< std::vector< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< std::vector< double,std::allocator< double > > > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vdouble2d_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &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 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vdouble2d_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
-  result = ((std::vector< std::vector< double > > const *)arg1)->get_allocator();
-  resultobj = 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 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vdouble2d_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::vector< double > >::size_type arg1 ;
@@ -13575,20 +13642,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -13601,7 +13668,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_erase(PyObject *self, PyObject *args) {
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -13645,7 +13712,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble2d_t__SWIG_3(PyObject *SWIGUNUSEDPARM(self
   } 
   arg1 = static_cast< std::vector< std::vector< double > >::size_type >(val1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_vdouble2d_t" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -13666,14 +13733,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vdouble2d_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -13692,7 +13759,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble2d_t(PyObject *self, PyObject *args) {
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vdouble2d_t__SWIG_1(self, args);
@@ -13705,7 +13772,7 @@ SWIGINTERN PyObject *_wrap_new_vdouble2d_t(PyObject *self, PyObject *args) {
       _v = SWIG_CheckState(res);
     }
     if (_v) {
-      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
+      int res = swig::asptr(argv[1], (std::vector<double,std::allocator< double > >**)(0));
       _v = SWIG_CheckState(res);
       if (_v) {
         return _wrap_new_vdouble2d_t__SWIG_3(self, args);
@@ -13741,7 +13808,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_push_back(PyObject *SWIGUNUSEDPARM(self),
   }
   arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vdouble2d_t_push_back" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -13776,7 +13843,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_front(PyObject *SWIGUNUSEDPARM(self), PyO
   }
   arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
   result = (std::vector< std::vector< double > >::value_type *) &((std::vector< std::vector< double > > const *)arg1)->front();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(*result));
   return resultobj;
 fail:
   return NULL;
@@ -13798,7 +13865,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_back(PyObject *SWIGUNUSEDPARM(self), PyOb
   }
   arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
   result = (std::vector< std::vector< double > >::value_type *) &((std::vector< std::vector< double > > const *)arg1)->back();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(*result));
   return resultobj;
 fail:
   return NULL;
@@ -13831,7 +13898,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_assign(PyObject *SWIGUNUSEDPARM(self), Py
   } 
   arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t_assign" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -13877,7 +13944,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(s
   } 
   arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t_resize" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -13898,20 +13965,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -13925,7 +13992,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_resize(PyObject *self, PyObject *args) {
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -13933,7 +14000,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_resize(PyObject *self, PyObject *args) {
         _v = SWIG_CheckState(res);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble2d_t_resize__SWIG_1(self, args);
@@ -13984,7 +14051,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(s
     }
   }
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vdouble2d_t_insert" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -14046,7 +14113,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(s
   } 
   arg3 = static_cast< std::vector< std::vector< double > >::size_type >(val3);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res4 = swig::asptr(obj3, &ptr);
     if (!SWIG_IsOK(res4)) {
       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vdouble2d_t_insert" "', argument " "4"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
@@ -14067,27 +14134,27 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vdouble2d_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
       _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<double,std::allocator< double > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vdouble2d_t_insert__SWIG_0(self, args);
@@ -14097,7 +14164,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_insert(PyObject *self, PyObject *args) {
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -14109,7 +14176,7 @@ SWIGINTERN PyObject *_wrap_vdouble2d_t_insert(PyObject *self, PyObject *args) {
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<double,std::allocator< double > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
             return _wrap_vdouble2d_t_insert__SWIG_1(self, args);
@@ -14298,6 +14365,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_integer_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< int >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_pop" "', argument " "1"" of type '" "std::vector< int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  try {
+    result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_int(static_cast< int >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_integer_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
@@ -14348,6 +14443,70 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::difference_type arg2 ;
+  std::vector< int >::difference_type arg3 ;
+  std::vector< int,std::allocator< int > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_integer_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_integer_t___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector< int >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_integer_t___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector< int >::difference_type >(val3);
+  {
+    std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_integer_t___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_integer_t___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  try {
+    std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
   std::vector< int >::difference_type arg2 ;
@@ -14395,85 +14554,21 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_integer_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
-  std::vector< int >::difference_type arg2 ;
-  std::vector< int >::difference_type arg3 ;
-  std::vector< int,std::allocator< int > > *arg4 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  ptrdiff_t val3 ;
-  int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_integer_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_integer_t___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
-  } 
-  arg2 = static_cast< std::vector< int >::difference_type >(val2);
-  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_integer_t___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
-  } 
-  arg3 = static_cast< std::vector< int >::difference_type >(val3);
-  {
-    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_integer_t___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_integer_t___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
-  try {
-    std_vector_Sl_int_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return resultobj;
-fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_integer_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -14486,14 +14581,14 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_integer_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_integer_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -14506,10 +14601,10 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<int,std::allocator< int > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_integer_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_integer_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -14519,8 +14614,8 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setslice__(PyObject *self, PyObjec
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_integer_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type)\n"
-    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type,std::vector< int,std::allocator< int > > const &)\n");
+    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type,std::vector< int,std::allocator< int > > const &)\n"
+    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type)\n");
   return 0;
 }
 
@@ -14601,9 +14696,6 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___delitem____SWIG_0(PyObject *SWIGUN
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -14676,7 +14768,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem____SWIG_0(PyObject *SWIGUN
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
+    std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_integer_t___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
@@ -14782,20 +14874,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -14808,7 +14900,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___delitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -14868,20 +14960,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -14894,7 +14986,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___getitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -14964,20 +15056,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -14990,14 +15082,14 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<int,std::allocator< int > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_integer_t___setitem____SWIG_0(self, args);
@@ -15007,7 +15099,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -15036,34 +15128,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_integer_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< int >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_pop" "', argument " "1"" of type '" "std::vector< int > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
-  try {
-    result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_From_int(static_cast< int >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_integer_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
@@ -15118,7 +15182,7 @@ SWIGINTERN PyObject *_wrap_new_vector_integer_t__SWIG_1(PyObject *SWIGUNUSEDPARM
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_integer_t",&obj0)) SWIG_fail;
   {
-    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
+    std::vector<int,std::allocator< int > > *ptr = (std::vector<int,std::allocator< int > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_integer_t" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
@@ -15182,6 +15246,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_integer_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_integer_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
@@ -15215,6 +15300,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_integer_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< int > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  result = ((std::vector< int > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_integer_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int > *arg1 = (std::vector< int > *) 0 ;
@@ -15307,49 +15414,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_integer_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_integer_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< int > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_integer_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_integer_t_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
-  result = ((std::vector< int > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vector_integer_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< int >::size_type arg1 ;
@@ -15515,20 +15579,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -15541,7 +15605,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t_erase(PyObject *self, PyObject *args
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -15601,14 +15665,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_integer_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -15627,7 +15691,7 @@ SWIGINTERN PyObject *_wrap_new_vector_integer_t(PyObject *self, PyObject *args)
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_integer_t__SWIG_1(self, args);
@@ -15820,20 +15884,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -15847,7 +15911,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t_resize(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -15981,20 +16045,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_integer_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -16013,7 +16077,7 @@ SWIGINTERN PyObject *_wrap_vector_integer_t_insert(PyObject *self, PyObject *arg
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<int,std::allocator< int > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -16216,6 +16280,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_longinteger_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< unsigned long >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_pop" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
+  try {
+    result = (std::vector< unsigned long >::value_type)std_vector_Sl_unsigned_SS_long_Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
@@ -16266,6 +16358,70 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
+  std::vector< unsigned long >::difference_type arg2 ;
+  std::vector< unsigned long >::difference_type arg3 ;
+  std::vector< unsigned long,std::allocator< unsigned long > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_longinteger_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t___setslice__" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_longinteger_t___setslice__" "', argument " "2"" of type '" "std::vector< unsigned long >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector< unsigned long >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_longinteger_t___setslice__" "', argument " "3"" of type '" "std::vector< unsigned long >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector< unsigned long >::difference_type >(val3);
+  {
+    std::vector<unsigned long,std::allocator< unsigned long > > *ptr = (std::vector<unsigned long,std::allocator< unsigned long > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_longinteger_t___setslice__" "', argument " "4"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_longinteger_t___setslice__" "', argument " "4"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  try {
+    std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< unsigned long,std::allocator< unsigned long > > const &)*arg4);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
   std::vector< unsigned long >::difference_type arg2 ;
@@ -16313,85 +16469,21 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
-  std::vector< unsigned long >::difference_type arg2 ;
-  std::vector< unsigned long >::difference_type arg3 ;
-  std::vector< unsigned long,std::allocator< unsigned long > > *arg4 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  ptrdiff_t val3 ;
-  int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_longinteger_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t___setslice__" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_longinteger_t___setslice__" "', argument " "2"" of type '" "std::vector< unsigned long >::difference_type""'");
-  } 
-  arg2 = static_cast< std::vector< unsigned long >::difference_type >(val2);
-  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_longinteger_t___setslice__" "', argument " "3"" of type '" "std::vector< unsigned long >::difference_type""'");
-  } 
-  arg3 = static_cast< std::vector< unsigned long >::difference_type >(val3);
-  {
-    std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_longinteger_t___setslice__" "', argument " "4"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_longinteger_t___setslice__" "', argument " "4"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
-  try {
-    std_vector_Sl_unsigned_SS_long_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< unsigned long,std::allocator< unsigned long > > const &)*arg4);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return resultobj;
-fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -16404,14 +16496,14 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice__(PyObject *self, PyO
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_longinteger_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_longinteger_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -16424,10 +16516,10 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice__(PyObject *self, PyO
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_longinteger_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_longinteger_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -16437,8 +16529,8 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setslice__(PyObject *self, PyO
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_longinteger_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< unsigned long >::__setslice__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::difference_type)\n"
-    "    std::vector< unsigned long >::__setslice__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::difference_type,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n");
+    "    std::vector< unsigned long >::__setslice__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::difference_type,std::vector< unsigned long,std::allocator< unsigned long > > const &)\n"
+    "    std::vector< unsigned long >::__setslice__(std::vector< unsigned long >::difference_type,std::vector< unsigned long >::difference_type)\n");
   return 0;
 }
 
@@ -16519,9 +16611,6 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem____SWIG_0(PyObject *SW
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -16594,7 +16683,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem____SWIG_0(PyObject *SW
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
+    std::vector<unsigned long,std::allocator< unsigned long > > *ptr = (std::vector<unsigned long,std::allocator< unsigned long > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_longinteger_t___setitem__" "', argument " "3"" of type '" "std::vector< unsigned long,std::allocator< unsigned long > > const &""'"); 
@@ -16700,20 +16789,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -16726,7 +16815,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___delitem__(PyObject *self, PyOb
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -16786,20 +16875,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -16812,7 +16901,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___getitem__(PyObject *self, PyOb
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -16882,20 +16971,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -16908,14 +16997,14 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyOb
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_longinteger_t___setitem____SWIG_0(self, args);
@@ -16925,7 +17014,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t___setitem__(PyObject *self, PyOb
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -16954,34 +17043,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_longinteger_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< unsigned long >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_pop" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
-  try {
-    result = (std::vector< unsigned long >::value_type)std_vector_Sl_unsigned_SS_long_Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
@@ -17036,7 +17097,7 @@ SWIGINTERN PyObject *_wrap_new_vector_longinteger_t__SWIG_1(PyObject *SWIGUNUSED
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_longinteger_t",&obj0)) SWIG_fail;
   {
-    std::vector< unsigned long,std::allocator< unsigned long > > *ptr = (std::vector< unsigned long,std::allocator< unsigned long > > *)0;
+    std::vector<unsigned long,std::allocator< unsigned long > > *ptr = (std::vector<unsigned long,std::allocator< unsigned long > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_longinteger_t" "', argument " "1"" of type '" "std::vector< unsigned long > const &""'"); 
@@ -17100,6 +17161,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_longinteger_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_clear" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
@@ -17133,6 +17215,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_longinteger_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< unsigned long > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_get_allocator" "', argument " "1"" of type '" "std::vector< unsigned long > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
+  result = ((std::vector< unsigned long > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< unsigned long >::allocator_type(static_cast< const std::vector< unsigned long >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_unsigned_long_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
@@ -17225,49 +17329,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_longinteger_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_clear" "', argument " "1"" of type '" "std::vector< unsigned long > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_longinteger_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< unsigned long > *arg1 = (std::vector< unsigned long > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< unsigned long > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_longinteger_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_long_std__allocatorT_unsigned_long_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_longinteger_t_get_allocator" "', argument " "1"" of type '" "std::vector< unsigned long > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< unsigned long > * >(argp1);
-  result = ((std::vector< unsigned long > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< unsigned long >::allocator_type(static_cast< const std::vector< unsigned long >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_unsigned_long_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vector_longinteger_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< unsigned long >::size_type arg1 ;
@@ -17433,20 +17494,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -17459,7 +17520,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t_erase(PyObject *self, PyObject *
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -17519,14 +17580,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_longinteger_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -17545,7 +17606,7 @@ SWIGINTERN PyObject *_wrap_new_vector_longinteger_t(PyObject *self, PyObject *ar
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_longinteger_t__SWIG_1(self, args);
@@ -17738,20 +17799,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -17765,7 +17826,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t_resize(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -17899,20 +17960,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_longinteger_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -17931,7 +17992,7 @@ SWIGINTERN PyObject *_wrap_vector_longinteger_t_insert(PyObject *self, PyObject
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< unsigned long,std::allocator< unsigned long > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<unsigned long,std::allocator< unsigned long > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -18134,6 +18195,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_complex_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< std::complex< double > >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_pop" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
+  try {
+    result = std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_complex_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
@@ -18184,6 +18273,70 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
+  std::vector< std::complex< double > >::difference_type arg2 ;
+  std::vector< std::complex< double > >::difference_type arg3 ;
+  std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_complex_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t___setslice__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_complex_t___setslice__" "', argument " "2"" of type '" "std::vector< std::complex< double > >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector< std::complex< double > >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_complex_t___setslice__" "', argument " "3"" of type '" "std::vector< std::complex< double > >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector< std::complex< double > >::difference_type >(val3);
+  {
+    std::vector<std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector<std::complex< double >,std::allocator< std::complex< double > > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_complex_t___setslice__" "', argument " "4"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_complex_t___setslice__" "', argument " "4"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  try {
+    std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)*arg4);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vector_complex_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
   std::vector< std::complex< double > >::difference_type arg2 ;
@@ -18231,85 +18384,21 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_complex_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
-  std::vector< std::complex< double > >::difference_type arg2 ;
-  std::vector< std::complex< double > >::difference_type arg3 ;
-  std::vector< std::complex< double >,std::allocator< std::complex< double > > > *arg4 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  ptrdiff_t val3 ;
-  int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_complex_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t___setslice__" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_complex_t___setslice__" "', argument " "2"" of type '" "std::vector< std::complex< double > >::difference_type""'");
-  } 
-  arg2 = static_cast< std::vector< std::complex< double > >::difference_type >(val2);
-  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_complex_t___setslice__" "', argument " "3"" of type '" "std::vector< std::complex< double > >::difference_type""'");
-  } 
-  arg3 = static_cast< std::vector< std::complex< double > >::difference_type >(val3);
-  {
-    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_complex_t___setslice__" "', argument " "4"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_complex_t___setslice__" "', argument " "4"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
-  try {
-    std_vector_Sl_std_complex_Sl_double_Sg__Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)*arg4);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return resultobj;
-fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_complex_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -18322,14 +18411,14 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_complex_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_complex_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -18342,10 +18431,10 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice__(PyObject *self, PyObjec
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_complex_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_complex_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -18355,8 +18444,8 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setslice__(PyObject *self, PyObjec
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_complex_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< std::complex< double > >::__setslice__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::difference_type)\n"
-    "    std::vector< std::complex< double > >::__setslice__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n");
+    "    std::vector< std::complex< double > >::__setslice__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &)\n"
+    "    std::vector< std::complex< double > >::__setslice__(std::vector< std::complex< double > >::difference_type,std::vector< std::complex< double > >::difference_type)\n");
   return 0;
 }
 
@@ -18437,9 +18526,6 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___delitem____SWIG_0(PyObject *SWIGUN
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -18512,7 +18598,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem____SWIG_0(PyObject *SWIGUN
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
+    std::vector<std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector<std::complex< double >,std::allocator< std::complex< double > > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_complex_t___setitem__" "', argument " "3"" of type '" "std::vector< std::complex< double >,std::allocator< std::complex< double > > > const &""'"); 
@@ -18618,20 +18704,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -18644,7 +18730,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___delitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -18704,20 +18790,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -18730,7 +18816,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___getitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -18800,20 +18886,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -18826,14 +18912,14 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_complex_t___setitem____SWIG_0(self, args);
@@ -18843,7 +18929,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -18872,34 +18958,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_complex_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< std::complex< double > >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_pop" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  try {
-    result = std_vector_Sl_std_complex_Sl_double_Sg__Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_From_std_complex_Sl_double_Sg_(static_cast< std::complex<double> >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_complex_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
@@ -18954,7 +19012,7 @@ SWIGINTERN PyObject *_wrap_new_vector_complex_t__SWIG_1(PyObject *SWIGUNUSEDPARM
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_complex_t",&obj0)) SWIG_fail;
   {
-    std::vector< std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector< std::complex< double >,std::allocator< std::complex< double > > > *)0;
+    std::vector<std::complex< double >,std::allocator< std::complex< double > > > *ptr = (std::vector<std::complex< double >,std::allocator< std::complex< double > > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_complex_t" "', argument " "1"" of type '" "std::vector< std::complex< double > > const &""'"); 
@@ -19018,6 +19076,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_complex_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_clear" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_complex_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
@@ -19051,6 +19130,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_complex_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< std::complex< double > > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
+  result = ((std::vector< std::complex< double > > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< std::complex< double > >::allocator_type(static_cast< const std::vector< std::complex< double > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__complexT_double_t_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_complex_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
@@ -19143,49 +19244,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_complex_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_clear" "', argument " "1"" of type '" "std::vector< std::complex< double > > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_complex_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::complex< double > > *arg1 = (std::vector< std::complex< double > > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< std::complex< double > > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_complex_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__complexT_double_t_std__allocatorT_std__complexT_double_t_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_complex_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::complex< double > > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::complex< double > > * >(argp1);
-  result = ((std::vector< std::complex< double > > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< std::complex< double > >::allocator_type(static_cast< const std::vector< std::complex< double > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__complexT_double_t_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vector_complex_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::complex< double > >::size_type arg1 ;
@@ -19351,20 +19409,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -19377,7 +19435,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t_erase(PyObject *self, PyObject *args
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -19437,14 +19495,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_complex_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -19463,7 +19521,7 @@ SWIGINTERN PyObject *_wrap_new_vector_complex_t(PyObject *self, PyObject *args)
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_complex_t__SWIG_1(self, args);
@@ -19656,20 +19714,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -19683,7 +19741,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t_resize(PyObject *self, PyObject *arg
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -19817,20 +19875,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_complex_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -19849,7 +19907,7 @@ SWIGINTERN PyObject *_wrap_vector_complex_t_insert(PyObject *self, PyObject *arg
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::complex< double >,std::allocator< std::complex< double > > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::complex< double >,std::allocator< std::complex< double > > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -20052,6 +20110,34 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_string_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::vector< std::string >::value_type result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_pop",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_pop" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
+  try {
+    result = std_vector_Sl_std_string_Sg__pop(arg1);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_string_t___getslice__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
@@ -20102,6 +20188,70 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t___setslice____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
+  std::vector< std::string >::difference_type arg2 ;
+  std::vector< std::string >::difference_type arg3 ;
+  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  ptrdiff_t val2 ;
+  int ecode2 = 0 ;
+  ptrdiff_t val3 ;
+  int ecode3 = 0 ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_string_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
+  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string_t___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
+  } 
+  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
+  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_string_t___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
+  } 
+  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
+  {
+    std::vector<std::string,std::allocator< std::string > > *ptr = (std::vector<std::string,std::allocator< std::string > > *)0;
+    res4 = swig::asptr(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_string_t___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_t___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  try {
+    std_vector_Sl_std_string_Sg____setslice____SWIG_0(arg1,arg2,arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
+  }
+  catch(std::out_of_range &_e) {
+    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
+  }
+  catch(std::invalid_argument &_e) {
+    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
+  }
+  
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_vector_string_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
   std::vector< std::string >::difference_type arg2 ;
@@ -20149,85 +20299,21 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_string_t___setslice____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
-  std::vector< std::string >::difference_type arg2 ;
-  std::vector< std::string >::difference_type arg3 ;
-  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  ptrdiff_t val2 ;
-  int ecode2 = 0 ;
-  ptrdiff_t val3 ;
-  int ecode3 = 0 ;
-  int res4 = SWIG_OLDOBJ ;
-  PyObject * obj0 = 0 ;
-  PyObject * obj1 = 0 ;
-  PyObject * obj2 = 0 ;
-  PyObject * obj3 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"OOOO:vector_string_t___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
-  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vector_string_t___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
-  } 
-  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
-  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
-  if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vector_string_t___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
-  } 
-  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
-  {
-    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
-    res4 = swig::asptr(obj3, &ptr);
-    if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vector_string_t___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
-    }
-    if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vector_string_t___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
-    }
-    arg4 = ptr;
-  }
-  try {
-    std_vector_Sl_std_string_Sg____setslice____SWIG_1(arg1,arg2,arg3,(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_Py_Void();
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return resultobj;
-fail:
-  if (SWIG_IsNewObj(res4)) delete arg4;
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_string_t___setslice__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -20240,14 +20326,14 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice__(PyObject *self, PyObject
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          return _wrap_vector_string_t___setslice____SWIG_0(self, args);
+          return _wrap_vector_string_t___setslice____SWIG_1(self, args);
         }
       }
     }
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -20260,10 +20346,10 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice__(PyObject *self, PyObject
           _v = SWIG_CheckState(res);
         }
         if (_v) {
-          int res = swig::asptr(argv[3], (std::vector< std::string,std::allocator< std::string > >**)(0));
+          int res = swig::asptr(argv[3], (std::vector<std::string,std::allocator< std::string > >**)(0));
           _v = SWIG_CheckState(res);
           if (_v) {
-            return _wrap_vector_string_t___setslice____SWIG_1(self, args);
+            return _wrap_vector_string_t___setslice____SWIG_0(self, args);
           }
         }
       }
@@ -20273,8 +20359,8 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setslice__(PyObject *self, PyObject
 fail:
   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'vector_string_t___setslice__'.\n"
     "  Possible C/C++ prototypes are:\n"
-    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type)\n"
-    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type,std::vector< std::string,std::allocator< std::string > > const &)\n");
+    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type,std::vector< std::string,std::allocator< std::string > > const &)\n"
+    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type)\n");
   return 0;
 }
 
@@ -20355,9 +20441,6 @@ SWIGINTERN PyObject *_wrap_vector_string_t___delitem____SWIG_0(PyObject *SWIGUNU
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
-  catch(std::invalid_argument &_e) {
-    SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
-  }
   
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -20430,7 +20513,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem____SWIG_0(PyObject *SWIGUNU
     arg2 = (PySliceObject *) obj1;
   }
   {
-    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
+    std::vector<std::string,std::allocator< std::string > > *ptr = (std::vector<std::string,std::allocator< std::string > > *)0;
     res3 = swig::asptr(obj2, &ptr);
     if (!SWIG_IsOK(res3)) {
       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "vector_string_t___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
@@ -20536,20 +20619,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t___delitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -20562,7 +20645,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___delitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -20622,20 +20705,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -20648,7 +20731,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___getitem__(PyObject *self, PyObject
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -20723,20 +20806,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -20749,14 +20832,14 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
         _v = PySlice_Check(argv[1]);
       }
       if (_v) {
-        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
+        int res = swig::asptr(argv[2], (std::vector<std::string,std::allocator< std::string > >**)(0));
         _v = SWIG_CheckState(res);
         if (_v) {
           return _wrap_vector_string_t___setitem____SWIG_0(self, args);
@@ -20766,7 +20849,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t___setitem__(PyObject *self, PyObject
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -20793,34 +20876,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_string_t_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  std::vector< std::string >::value_type result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_pop" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
-  try {
-    result = std_vector_Sl_std_string_Sg__pop(arg1);
-  }
-  catch(std::out_of_range &_e) {
-    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
-  }
-  
-  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_vector_string_t_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
@@ -20880,7 +20935,7 @@ SWIGINTERN PyObject *_wrap_new_vector_string_t__SWIG_1(PyObject *SWIGUNUSEDPARM(
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vector_string_t",&obj0)) SWIG_fail;
   {
-    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
+    std::vector<std::string,std::allocator< std::string > > *ptr = (std::vector<std::string,std::allocator< std::string > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vector_string_t" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
@@ -20944,6 +20999,27 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_string_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_clear",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_clear" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
+  (arg1)->clear();
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_string_t_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
@@ -20977,6 +21053,28 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_vector_string_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  SwigValueWrapper< std::allocator< std::string > > result;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_get_allocator",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
+  }
+  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
+  result = ((std::vector< std::string > const *)arg1)->get_allocator();
+  resultobj = SWIG_NewPointerObj((new std::vector< std::string >::allocator_type(static_cast< const std::vector< std::string >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
 SWIGINTERN PyObject *_wrap_vector_string_t_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
@@ -21069,49 +21167,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vector_string_t_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_clear" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
-  (arg1)->clear();
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vector_string_t_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  SwigValueWrapper< std::allocator< std::string > > result;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vector_string_t_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vector_string_t_get_allocator" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
-  result = ((std::vector< std::string > const *)arg1)->get_allocator();
-  resultobj = SWIG_NewPointerObj((new std::vector< std::string >::allocator_type(static_cast< const std::vector< std::string >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN |  0 );
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vector_string_t__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   std::vector< std::string >::size_type arg1 ;
@@ -21277,20 +21332,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t_erase(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -21303,7 +21358,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t_erase(PyObject *self, PyObject *args)
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -21368,14 +21423,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_vector_string_t(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -21394,7 +21449,7 @@ SWIGINTERN PyObject *_wrap_new_vector_string_t(PyObject *self, PyObject *args) {
   }
   if (argc == 1) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_new_vector_string_t__SWIG_1(self, args);
@@ -21600,20 +21655,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t_resize(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -21627,7 +21682,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t_resize(PyObject *self, PyObject *args
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -21769,20 +21824,20 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_vector_string_t_insert(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 3) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -21799,7 +21854,7 @@ SWIGINTERN PyObject *_wrap_vector_string_t_insert(PyObject *self, PyObject *args
   }
   if (argc == 4) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<std::string,std::allocator< std::string > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       swig::SwigPyIterator *iter = 0;
@@ -22094,14 +22149,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IChiSquaredModule_setChiSquaredFunction(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -22217,14 +22272,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IChiSquaredModule_getIntensityNormalizer(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -22486,14 +22541,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_IChiSquaredModule(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -23064,14 +23119,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_IFitStrategy(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -24272,14 +24327,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_IntensityNormalizer(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -24749,14 +24804,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_IntensityScaleAndShiftNormalizer(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -25273,14 +25328,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_ISquaredFunction_calculateSquaredError(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -25596,14 +25651,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_SquaredFunctionDefault_calculateSquaredError(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -26187,14 +26242,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_SquaredFunctionSystematicError(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -26484,14 +26539,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_SquaredFunctionGaussianError(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -27163,7 +27218,7 @@ SWIGINTERN PyObject *_wrap_IMinimizer_getValueOfVariablesAtMinimum(PyObject *SWI
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -27240,7 +27295,7 @@ SWIGINTERN PyObject *_wrap_IMinimizer_getErrorOfVariables(PyObject *SWIGUNUSEDPA
   } catch (Swig::DirectorException&) {
     SWIG_fail;
   }
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -27422,14 +27477,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_IMinimizer_getOptions(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -27746,14 +27801,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_ChiSquaredModule(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -28114,14 +28169,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_FitObject(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[6] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 5) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -28424,14 +28479,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitObject_prepareFitElements(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -28664,14 +28719,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitObject_addParametersToExternalPool(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -29265,14 +29320,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_new_FitParameter(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[7] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 6) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -29898,14 +29953,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_addSimulationAndRealData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -30173,14 +30228,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_addFitParameter(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[6] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 5) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -30522,14 +30577,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_setMinimizer(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -30732,7 +30787,7 @@ SWIGINTERN PyObject *_wrap_FitSuite_setParametersFixed(PyObject *SWIGUNUSEDPARM(
   }
   arg1 = reinterpret_cast< FitSuite * >(argp1);
   {
-    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
+    std::vector<std::string,std::allocator< std::string > > *ptr = (std::vector<std::string,std::allocator< std::string > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FitSuite_setParametersFixed" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
@@ -30854,14 +30909,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_getRealData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -30953,14 +31008,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_getSimulationData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -31052,14 +31107,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_getChiSquaredMap(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -31390,14 +31445,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_getRealOutputData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -31489,14 +31544,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_getSimulationOutputData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -31588,14 +31643,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuite_getChiSquaredOutputData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -31829,14 +31884,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteObjects_add(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -32021,14 +32076,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteObjects_getRealData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -32120,14 +32175,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteObjects_getSimulationData(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -32219,14 +32274,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteObjects_getChiSquaredMap(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -32456,14 +32511,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteObjects_addParametersToExternalPool(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[5] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 4) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -32900,14 +32955,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteParameters_addParameter(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[7] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 6) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -33076,14 +33131,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteParameters_getParameter(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -33170,7 +33225,7 @@ SWIGINTERN PyObject *_wrap_FitSuiteParameters_setValues__SWIG_1(PyObject *SWIGUN
   }
   arg1 = reinterpret_cast< FitSuiteParameters * >(argp1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FitSuiteParameters_setValues" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -33191,14 +33246,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteParameters_setValues(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -33222,7 +33277,7 @@ SWIGINTERN PyObject *_wrap_FitSuiteParameters_setValues(PyObject *self, PyObject
     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FitSuiteParameters, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
-      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
+      int res = swig::asptr(argv[1], (std::vector<double,std::allocator< double > >**)(0));
       _v = SWIG_CheckState(res);
       if (_v) {
         return _wrap_FitSuiteParameters_setValues__SWIG_1(self, args);
@@ -33254,7 +33309,7 @@ SWIGINTERN PyObject *_wrap_FitSuiteParameters_getValues(PyObject *SWIGUNUSEDPARM
   }
   arg1 = reinterpret_cast< FitSuiteParameters * >(argp1);
   result = ((FitSuiteParameters const *)arg1)->getValues();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -33278,7 +33333,7 @@ SWIGINTERN PyObject *_wrap_FitSuiteParameters_setErrors(PyObject *SWIGUNUSEDPARM
   }
   arg1 = reinterpret_cast< FitSuiteParameters * >(argp1);
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FitSuiteParameters_setErrors" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -33313,7 +33368,7 @@ SWIGINTERN PyObject *_wrap_FitSuiteParameters_getErrors(PyObject *SWIGUNUSEDPARM
   }
   arg1 = reinterpret_cast< FitSuiteParameters * >(argp1);
   result = ((FitSuiteParameters const *)arg1)->getErrors();
-  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
+  resultobj = swig::from(static_cast< std::vector<double,std::allocator< double > > >(result));
   return resultobj;
 fail:
   return NULL;
@@ -33417,14 +33472,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteParameters_begin(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -33501,14 +33556,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteParameters_end(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -33664,14 +33719,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteParameters_valuesAreDifferrent(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -33803,7 +33858,7 @@ SWIGINTERN PyObject *_wrap_FitSuiteParameters_setParametersFixed(PyObject *SWIGU
   }
   arg1 = reinterpret_cast< FitSuiteParameters * >(argp1);
   {
-    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
+    std::vector<std::string,std::allocator< std::string > > *ptr = (std::vector<std::string,std::allocator< std::string > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FitSuiteParameters_setParametersFixed" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
@@ -33907,14 +33962,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FitSuiteParameters___getitem__(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -34165,14 +34220,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_sinc(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -34370,14 +34425,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Bessel_J0(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -34440,14 +34495,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Bessel_J1(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -34510,14 +34565,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_Bessel_J1c(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[2] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -34618,7 +34673,7 @@ SWIGINTERN PyObject *_wrap_FastFourierTransform__SWIG_1(PyObject *SWIGUNUSEDPARM
   
   if (!PyArg_ParseTuple(args,(char *)"OO:FastFourierTransform",&obj0,&obj1)) SWIG_fail;
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FastFourierTransform" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -34644,14 +34699,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_FastFourierTransform(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[3] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -34671,7 +34726,7 @@ SWIGINTERN PyObject *_wrap_FastFourierTransform(PyObject *self, PyObject *args)
   }
   if (argc == 2) {
     int _v;
-    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    int res = swig::asptr(argv[0], (std::vector<double,std::allocator< double > >**)(0));
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -34705,7 +34760,7 @@ SWIGINTERN PyObject *_wrap_ConvolveFFT(PyObject *SWIGUNUSEDPARM(self), PyObject
   
   if (!PyArg_ParseTuple(args,(char *)"OO:ConvolveFFT",&obj0,&obj1)) SWIG_fail;
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res1 = swig::asptr(obj0, &ptr);
     if (!SWIG_IsOK(res1)) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvolveFFT" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -34716,7 +34771,7 @@ SWIGINTERN PyObject *_wrap_ConvolveFFT(PyObject *SWIGUNUSEDPARM(self), PyObject
     arg1 = ptr;
   }
   {
-    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    std::vector<double,std::allocator< double > > *ptr = (std::vector<double,std::allocator< double > > *)0;
     res2 = swig::asptr(obj1, &ptr);
     if (!SWIG_IsOK(res2)) {
       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvolveFFT" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
@@ -35037,14 +35092,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_MinimizerFactory_createMinimizer(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -35586,14 +35641,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_MinimizerOptions_setValue(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -35811,14 +35866,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_MinimizerOptions_getValue(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -36033,14 +36088,14 @@ fail:
 
 
 SWIGINTERN PyObject *_wrap_MinimizerOptions_addValue(PyObject *self, PyObject *args) {
-  Py_ssize_t argc;
+  int argc;
   PyObject *argv[4] = {
     0
   };
-  Py_ssize_t ii;
+  int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = args ? PyObject_Length(args) : 0;
+  argc = args ? (int)PyObject_Length(args) : 0;
   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -36252,6 +36307,790 @@ SWIGINTERN PyObject *MinimizerOptions_swigregister(PyObject *SWIGUNUSEDPARM(self
   return SWIG_Py_Void();
 }
 
+SWIGINTERN PyObject *_wrap_new_FitStrategyAdjustMinimizer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  PyObject * obj0 = 0 ;
+  FitStrategyAdjustMinimizer *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:new_FitStrategyAdjustMinimizer",&obj0)) SWIG_fail;
+  arg1 = obj0;
+  if ( arg1 != Py_None ) {
+    /* subclassed */
+    result = (FitStrategyAdjustMinimizer *)new SwigDirector_FitStrategyAdjustMinimizer(arg1); 
+  } else {
+    result = (FitStrategyAdjustMinimizer *)new FitStrategyAdjustMinimizer(); 
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FitStrategyAdjustMinimizer, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FitStrategyAdjustMinimizer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  std::string *arg2 = 0 ;
+  std::string *arg3 = 0 ;
+  std::string *arg4 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  int res3 = SWIG_OLDOBJ ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  FitStrategyAdjustMinimizer *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:new_FitStrategyAdjustMinimizer",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  arg1 = obj0;
+  {
+    std::string *ptr = (std::string *)0;
+    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FitStrategyAdjustMinimizer" "', argument " "2"" of type '" "std::string const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FitStrategyAdjustMinimizer" "', argument " "2"" of type '" "std::string const &""'"); 
+    }
+    arg2 = ptr;
+  }
+  {
+    std::string *ptr = (std::string *)0;
+    res3 = SWIG_AsPtr_std_string(obj2, &ptr);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FitStrategyAdjustMinimizer" "', argument " "3"" of type '" "std::string const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FitStrategyAdjustMinimizer" "', argument " "3"" of type '" "std::string const &""'"); 
+    }
+    arg3 = ptr;
+  }
+  {
+    std::string *ptr = (std::string *)0;
+    res4 = SWIG_AsPtr_std_string(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_FitStrategyAdjustMinimizer" "', argument " "4"" of type '" "std::string const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FitStrategyAdjustMinimizer" "', argument " "4"" of type '" "std::string const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  if ( arg1 != Py_None ) {
+    /* subclassed */
+    result = (FitStrategyAdjustMinimizer *)new SwigDirector_FitStrategyAdjustMinimizer(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4); 
+  } else {
+    result = (FitStrategyAdjustMinimizer *)new FitStrategyAdjustMinimizer((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4); 
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FitStrategyAdjustMinimizer, SWIG_POINTER_NEW |  0 );
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  if (SWIG_IsNewObj(res3)) delete arg3;
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  if (SWIG_IsNewObj(res3)) delete arg3;
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FitStrategyAdjustMinimizer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  std::string *arg2 = 0 ;
+  std::string *arg3 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  int res3 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  FitStrategyAdjustMinimizer *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:new_FitStrategyAdjustMinimizer",&obj0,&obj1,&obj2)) SWIG_fail;
+  arg1 = obj0;
+  {
+    std::string *ptr = (std::string *)0;
+    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FitStrategyAdjustMinimizer" "', argument " "2"" of type '" "std::string const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FitStrategyAdjustMinimizer" "', argument " "2"" of type '" "std::string const &""'"); 
+    }
+    arg2 = ptr;
+  }
+  {
+    std::string *ptr = (std::string *)0;
+    res3 = SWIG_AsPtr_std_string(obj2, &ptr);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FitStrategyAdjustMinimizer" "', argument " "3"" of type '" "std::string const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FitStrategyAdjustMinimizer" "', argument " "3"" of type '" "std::string const &""'"); 
+    }
+    arg3 = ptr;
+  }
+  if ( arg1 != Py_None ) {
+    /* subclassed */
+    result = (FitStrategyAdjustMinimizer *)new SwigDirector_FitStrategyAdjustMinimizer(arg1,(std::string const &)*arg2,(std::string const &)*arg3); 
+  } else {
+    result = (FitStrategyAdjustMinimizer *)new FitStrategyAdjustMinimizer((std::string const &)*arg2,(std::string const &)*arg3); 
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FitStrategyAdjustMinimizer, SWIG_POINTER_NEW |  0 );
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  if (SWIG_IsNewObj(res3)) delete arg3;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  if (SWIG_IsNewObj(res3)) delete arg3;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FitStrategyAdjustMinimizer__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  PyObject *arg1 = (PyObject *) 0 ;
+  std::string *arg2 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  FitStrategyAdjustMinimizer *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:new_FitStrategyAdjustMinimizer",&obj0,&obj1)) SWIG_fail;
+  arg1 = obj0;
+  {
+    std::string *ptr = (std::string *)0;
+    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FitStrategyAdjustMinimizer" "', argument " "2"" of type '" "std::string const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FitStrategyAdjustMinimizer" "', argument " "2"" of type '" "std::string const &""'"); 
+    }
+    arg2 = ptr;
+  }
+  if ( arg1 != Py_None ) {
+    /* subclassed */
+    result = (FitStrategyAdjustMinimizer *)new SwigDirector_FitStrategyAdjustMinimizer(arg1,(std::string const &)*arg2); 
+  } else {
+    result = (FitStrategyAdjustMinimizer *)new FitStrategyAdjustMinimizer((std::string const &)*arg2); 
+  }
+  
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FitStrategyAdjustMinimizer, SWIG_POINTER_NEW |  0 );
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FitStrategyAdjustMinimizer(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5] = {
+    0
+  };
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? (int)PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 1) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      return _wrap_new_FitStrategyAdjustMinimizer__SWIG_0(self, args);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_new_FitStrategyAdjustMinimizer__SWIG_3(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_new_FitStrategyAdjustMinimizer__SWIG_2(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    _v = (argv[0] != 0);
+    if (_v) {
+      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_new_FitStrategyAdjustMinimizer__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_FitStrategyAdjustMinimizer'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    FitStrategyAdjustMinimizer::FitStrategyAdjustMinimizer()\n"
+    "    FitStrategyAdjustMinimizer::FitStrategyAdjustMinimizer(std::string const &,std::string const &,std::string const &)\n"
+    "    FitStrategyAdjustMinimizer::FitStrategyAdjustMinimizer(std::string const &,std::string const &)\n"
+    "    FitStrategyAdjustMinimizer::FitStrategyAdjustMinimizer(PyObject *,std::string const &)\n");
+  return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_FitStrategyAdjustMinimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FitStrategyAdjustMinimizer *arg1 = (FitStrategyAdjustMinimizer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_FitStrategyAdjustMinimizer",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FitStrategyAdjustMinimizer, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FitStrategyAdjustMinimizer" "', argument " "1"" of type '" "FitStrategyAdjustMinimizer *""'"); 
+  }
+  arg1 = reinterpret_cast< FitStrategyAdjustMinimizer * >(argp1);
+  delete arg1;
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FitStrategyAdjustMinimizer_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FitStrategyAdjustMinimizer *arg1 = (FitStrategyAdjustMinimizer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  FitStrategyAdjustMinimizer *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FitStrategyAdjustMinimizer_clone",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FitStrategyAdjustMinimizer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FitStrategyAdjustMinimizer_clone" "', argument " "1"" of type '" "FitStrategyAdjustMinimizer const *""'"); 
+  }
+  arg1 = reinterpret_cast< FitStrategyAdjustMinimizer * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    if (upcall) {
+      result = (FitStrategyAdjustMinimizer *)((FitStrategyAdjustMinimizer const *)arg1)->FitStrategyAdjustMinimizer::clone();
+    } else {
+      result = (FitStrategyAdjustMinimizer *)((FitStrategyAdjustMinimizer const *)arg1)->clone();
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  director = SWIG_DIRECTOR_CAST(result);
+  if (director) {
+    resultobj = director->swig_get_self();
+    Py_INCREF(resultobj);
+  } else {
+    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FitStrategyAdjustMinimizer, 0 |  0 );
+  }
+  if (director) {
+    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
+  }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FitStrategyAdjustMinimizer_getMinimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FitStrategyAdjustMinimizer *arg1 = (FitStrategyAdjustMinimizer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  IMinimizer *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FitStrategyAdjustMinimizer_getMinimizer",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FitStrategyAdjustMinimizer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FitStrategyAdjustMinimizer_getMinimizer" "', argument " "1"" of type '" "FitStrategyAdjustMinimizer *""'"); 
+  }
+  arg1 = reinterpret_cast< FitStrategyAdjustMinimizer * >(argp1);
+  result = (IMinimizer *)(arg1)->getMinimizer();
+  director = SWIG_DIRECTOR_CAST(result);
+  if (director) {
+    resultobj = director->swig_get_self();
+    Py_INCREF(resultobj);
+  } else {
+    resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IMinimizer, 0 |  0 );
+  }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FitStrategyAdjustMinimizer_setMinimizer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FitStrategyAdjustMinimizer *arg1 = (FitStrategyAdjustMinimizer *) 0 ;
+  IMinimizer *arg2 = (IMinimizer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FitStrategyAdjustMinimizer_setMinimizer",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FitStrategyAdjustMinimizer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "1"" of type '" "FitStrategyAdjustMinimizer *""'"); 
+  }
+  arg1 = reinterpret_cast< FitStrategyAdjustMinimizer * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_IMinimizer, 0 |  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "2"" of type '" "IMinimizer *""'"); 
+  }
+  arg2 = reinterpret_cast< IMinimizer * >(argp2);
+  (arg1)->setMinimizer(arg2);
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FitStrategyAdjustMinimizer_setMinimizer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FitStrategyAdjustMinimizer *arg1 = (FitStrategyAdjustMinimizer *) 0 ;
+  std::string *arg2 = 0 ;
+  std::string *arg3 = 0 ;
+  std::string *arg4 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  int res3 = SWIG_OLDOBJ ;
+  int res4 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  PyObject * obj3 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOOO:FitStrategyAdjustMinimizer_setMinimizer",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FitStrategyAdjustMinimizer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "1"" of type '" "FitStrategyAdjustMinimizer *""'"); 
+  }
+  arg1 = reinterpret_cast< FitStrategyAdjustMinimizer * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "2"" of type '" "std::string const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "2"" of type '" "std::string const &""'"); 
+    }
+    arg2 = ptr;
+  }
+  {
+    std::string *ptr = (std::string *)0;
+    res3 = SWIG_AsPtr_std_string(obj2, &ptr);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "3"" of type '" "std::string const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "3"" of type '" "std::string const &""'"); 
+    }
+    arg3 = ptr;
+  }
+  {
+    std::string *ptr = (std::string *)0;
+    res4 = SWIG_AsPtr_std_string(obj3, &ptr);
+    if (!SWIG_IsOK(res4)) {
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "4"" of type '" "std::string const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "4"" of type '" "std::string const &""'"); 
+    }
+    arg4 = ptr;
+  }
+  (arg1)->setMinimizer((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  if (SWIG_IsNewObj(res3)) delete arg3;
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  if (SWIG_IsNewObj(res3)) delete arg3;
+  if (SWIG_IsNewObj(res4)) delete arg4;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FitStrategyAdjustMinimizer_setMinimizer__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FitStrategyAdjustMinimizer *arg1 = (FitStrategyAdjustMinimizer *) 0 ;
+  std::string *arg2 = 0 ;
+  std::string *arg3 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  int res3 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  PyObject * obj2 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OOO:FitStrategyAdjustMinimizer_setMinimizer",&obj0,&obj1,&obj2)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FitStrategyAdjustMinimizer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "1"" of type '" "FitStrategyAdjustMinimizer *""'"); 
+  }
+  arg1 = reinterpret_cast< FitStrategyAdjustMinimizer * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "2"" of type '" "std::string const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "2"" of type '" "std::string const &""'"); 
+    }
+    arg2 = ptr;
+  }
+  {
+    std::string *ptr = (std::string *)0;
+    res3 = SWIG_AsPtr_std_string(obj2, &ptr);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "3"" of type '" "std::string const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "3"" of type '" "std::string const &""'"); 
+    }
+    arg3 = ptr;
+  }
+  (arg1)->setMinimizer((std::string const &)*arg2,(std::string const &)*arg3);
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  if (SWIG_IsNewObj(res3)) delete arg3;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  if (SWIG_IsNewObj(res3)) delete arg3;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FitStrategyAdjustMinimizer_setMinimizer__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FitStrategyAdjustMinimizer *arg1 = (FitStrategyAdjustMinimizer *) 0 ;
+  std::string *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int res2 = SWIG_OLDOBJ ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FitStrategyAdjustMinimizer_setMinimizer",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FitStrategyAdjustMinimizer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "1"" of type '" "FitStrategyAdjustMinimizer *""'"); 
+  }
+  arg1 = reinterpret_cast< FitStrategyAdjustMinimizer * >(argp1);
+  {
+    std::string *ptr = (std::string *)0;
+    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "2"" of type '" "std::string const &""'"); 
+    }
+    if (!ptr) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FitStrategyAdjustMinimizer_setMinimizer" "', argument " "2"" of type '" "std::string const &""'"); 
+    }
+    arg2 = ptr;
+  }
+  (arg1)->setMinimizer((std::string const &)*arg2);
+  resultobj = SWIG_Py_Void();
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return resultobj;
+fail:
+  if (SWIG_IsNewObj(res2)) delete arg2;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FitStrategyAdjustMinimizer_setMinimizer(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[5] = {
+    0
+  };
+  int ii;
+  
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? (int)PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 4) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FitStrategyAdjustMinimizer, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      void *vptr = 0;
+      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_IMinimizer, 0);
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FitStrategyAdjustMinimizer_setMinimizer__SWIG_0(self, args);
+      }
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FitStrategyAdjustMinimizer, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        return _wrap_FitStrategyAdjustMinimizer_setMinimizer__SWIG_3(self, args);
+      }
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FitStrategyAdjustMinimizer, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          return _wrap_FitStrategyAdjustMinimizer_setMinimizer__SWIG_2(self, args);
+        }
+      }
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    void *vptr = 0;
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FitStrategyAdjustMinimizer, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
+      _v = SWIG_CheckState(res);
+      if (_v) {
+        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
+        _v = SWIG_CheckState(res);
+        if (_v) {
+          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
+          _v = SWIG_CheckState(res);
+          if (_v) {
+            return _wrap_FitStrategyAdjustMinimizer_setMinimizer__SWIG_1(self, args);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'FitStrategyAdjustMinimizer_setMinimizer'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    FitStrategyAdjustMinimizer::setMinimizer(IMinimizer *)\n"
+    "    FitStrategyAdjustMinimizer::setMinimizer(std::string const &,std::string const &,std::string const &)\n"
+    "    FitStrategyAdjustMinimizer::setMinimizer(std::string const &,std::string const &)\n"
+    "    FitStrategyAdjustMinimizer::setMinimizer(std::string const &)\n");
+  return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_FitStrategyAdjustMinimizer_execute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FitStrategyAdjustMinimizer *arg1 = (FitStrategyAdjustMinimizer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FitStrategyAdjustMinimizer_execute",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FitStrategyAdjustMinimizer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FitStrategyAdjustMinimizer_execute" "', argument " "1"" of type '" "FitStrategyAdjustMinimizer *""'"); 
+  }
+  arg1 = reinterpret_cast< FitStrategyAdjustMinimizer * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    if (upcall) {
+      (arg1)->FitStrategyAdjustMinimizer::execute();
+    } else {
+      (arg1)->execute();
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FitStrategyAdjustMinimizer_getMinimizerOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FitStrategyAdjustMinimizer *arg1 = (FitStrategyAdjustMinimizer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  MinimizerOptions *result = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:FitStrategyAdjustMinimizer_getMinimizerOptions",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FitStrategyAdjustMinimizer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FitStrategyAdjustMinimizer_getMinimizerOptions" "', argument " "1"" of type '" "FitStrategyAdjustMinimizer *""'"); 
+  }
+  arg1 = reinterpret_cast< FitStrategyAdjustMinimizer * >(argp1);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    if (upcall) {
+      result = (MinimizerOptions *)(arg1)->FitStrategyAdjustMinimizer::getMinimizerOptions();
+    } else {
+      result = (MinimizerOptions *)(arg1)->getMinimizerOptions();
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MinimizerOptions, 0 |  0 );
+  if (director) {
+    SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result)));
+  }
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_FitStrategyAdjustMinimizer__print(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FitStrategyAdjustMinimizer *arg1 = (FitStrategyAdjustMinimizer *) 0 ;
+  std::ostream *arg2 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 = 0 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+  Swig::Director *director = 0;
+  bool upcall = false;
+  SwigDirector_FitStrategyAdjustMinimizer *darg = 0;
+  
+  if (!PyArg_ParseTuple(args,(char *)"OO:FitStrategyAdjustMinimizer__print",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FitStrategyAdjustMinimizer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FitStrategyAdjustMinimizer__print" "', argument " "1"" of type '" "FitStrategyAdjustMinimizer const *""'"); 
+  }
+  arg1 = reinterpret_cast< FitStrategyAdjustMinimizer * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream,  0 );
+  if (!SWIG_IsOK(res2)) {
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FitStrategyAdjustMinimizer__print" "', argument " "2"" of type '" "std::ostream &""'"); 
+  }
+  if (!argp2) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FitStrategyAdjustMinimizer__print" "', argument " "2"" of type '" "std::ostream &""'"); 
+  }
+  arg2 = reinterpret_cast< std::ostream * >(argp2);
+  director = SWIG_DIRECTOR_CAST(arg1);
+  if (!director || !(director->swig_get_inner("print"))) {
+    SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing protected member print");
+    SWIG_fail;
+  }
+  upcall = (director && (director->swig_get_self()==obj0));
+  try {
+    darg = dynamic_cast<SwigDirector_FitStrategyAdjustMinimizer *>(arg1);
+    if (upcall) {
+      ((SwigDirector_FitStrategyAdjustMinimizer const *)darg)->printSwigPublic(*arg2);
+    } else {
+      ((SwigDirector_FitStrategyAdjustMinimizer const *)darg)->print(*arg2);
+    }
+  } catch (Swig::DirectorException&) {
+    SWIG_fail;
+  }
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_disown_FitStrategyAdjustMinimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  FitStrategyAdjustMinimizer *arg1 = (FitStrategyAdjustMinimizer *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  
+  if (!PyArg_ParseTuple(args,(char *)"O:disown_FitStrategyAdjustMinimizer",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_FitStrategyAdjustMinimizer, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_FitStrategyAdjustMinimizer" "', argument " "1"" of type '" "FitStrategyAdjustMinimizer *""'"); 
+  }
+  arg1 = reinterpret_cast< FitStrategyAdjustMinimizer * >(argp1);
+  {
+    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
+    if (director) director->swig_disown();
+  }
+  
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *FitStrategyAdjustMinimizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_FitStrategyAdjustMinimizer, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
 static PyMethodDef SwigMethods[] = {
 	 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
 	 { (char *)"delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_VARARGS, (char *)"delete_SwigPyIterator(SwigPyIterator self)"},
@@ -36286,10 +37125,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vdouble1d_t___nonzero__", _wrap_vdouble1d_t___nonzero__, METH_VARARGS, (char *)"vdouble1d_t___nonzero__(vdouble1d_t self) -> bool"},
 	 { (char *)"vdouble1d_t___bool__", _wrap_vdouble1d_t___bool__, METH_VARARGS, (char *)"vdouble1d_t___bool__(vdouble1d_t self) -> bool"},
 	 { (char *)"vdouble1d_t___len__", _wrap_vdouble1d_t___len__, METH_VARARGS, (char *)"vdouble1d_t___len__(vdouble1d_t self) -> std::vector< double >::size_type"},
+	 { (char *)"vdouble1d_t_pop", _wrap_vdouble1d_t_pop, METH_VARARGS, (char *)"vdouble1d_t_pop(vdouble1d_t self) -> std::vector< double >::value_type"},
 	 { (char *)"vdouble1d_t___getslice__", _wrap_vdouble1d_t___getslice__, METH_VARARGS, (char *)"vdouble1d_t___getslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> vdouble1d_t"},
 	 { (char *)"vdouble1d_t___setslice__", _wrap_vdouble1d_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< double >::difference_type i, std::vector< double >::difference_type j)\n"
-		"vdouble1d_t___setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, vdouble1d_t v)\n"
+		"__setslice__(std::vector< double >::difference_type i, std::vector< double >::difference_type j, vdouble1d_t v)\n"
+		"vdouble1d_t___setslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)\n"
 		""},
 	 { (char *)"vdouble1d_t___delslice__", _wrap_vdouble1d_t___delslice__, METH_VARARGS, (char *)"vdouble1d_t___delslice__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"},
 	 { (char *)"vdouble1d_t___delitem__", _wrap_vdouble1d_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -36305,17 +37145,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vdouble1d_t___setitem__(vdouble1d_t self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)\n"
 		""},
-	 { (char *)"vdouble1d_t_pop", _wrap_vdouble1d_t_pop, METH_VARARGS, (char *)"vdouble1d_t_pop(vdouble1d_t self) -> std::vector< double >::value_type"},
 	 { (char *)"vdouble1d_t_append", _wrap_vdouble1d_t_append, METH_VARARGS, (char *)"vdouble1d_t_append(vdouble1d_t self, std::vector< double >::value_type const & x)"},
 	 { (char *)"vdouble1d_t_empty", _wrap_vdouble1d_t_empty, METH_VARARGS, (char *)"vdouble1d_t_empty(vdouble1d_t self) -> bool"},
 	 { (char *)"vdouble1d_t_size", _wrap_vdouble1d_t_size, METH_VARARGS, (char *)"vdouble1d_t_size(vdouble1d_t self) -> std::vector< double >::size_type"},
+	 { (char *)"vdouble1d_t_clear", _wrap_vdouble1d_t_clear, METH_VARARGS, (char *)"vdouble1d_t_clear(vdouble1d_t self)"},
 	 { (char *)"vdouble1d_t_swap", _wrap_vdouble1d_t_swap, METH_VARARGS, (char *)"vdouble1d_t_swap(vdouble1d_t self, vdouble1d_t v)"},
+	 { (char *)"vdouble1d_t_get_allocator", _wrap_vdouble1d_t_get_allocator, METH_VARARGS, (char *)"vdouble1d_t_get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"},
 	 { (char *)"vdouble1d_t_begin", _wrap_vdouble1d_t_begin, METH_VARARGS, (char *)"vdouble1d_t_begin(vdouble1d_t self) -> std::vector< double >::iterator"},
 	 { (char *)"vdouble1d_t_end", _wrap_vdouble1d_t_end, METH_VARARGS, (char *)"vdouble1d_t_end(vdouble1d_t self) -> std::vector< double >::iterator"},
 	 { (char *)"vdouble1d_t_rbegin", _wrap_vdouble1d_t_rbegin, METH_VARARGS, (char *)"vdouble1d_t_rbegin(vdouble1d_t self) -> std::vector< double >::reverse_iterator"},
 	 { (char *)"vdouble1d_t_rend", _wrap_vdouble1d_t_rend, METH_VARARGS, (char *)"vdouble1d_t_rend(vdouble1d_t self) -> std::vector< double >::reverse_iterator"},
-	 { (char *)"vdouble1d_t_clear", _wrap_vdouble1d_t_clear, METH_VARARGS, (char *)"vdouble1d_t_clear(vdouble1d_t self)"},
-	 { (char *)"vdouble1d_t_get_allocator", _wrap_vdouble1d_t_get_allocator, METH_VARARGS, (char *)"vdouble1d_t_get_allocator(vdouble1d_t self) -> std::vector< double >::allocator_type"},
 	 { (char *)"vdouble1d_t_pop_back", _wrap_vdouble1d_t_pop_back, METH_VARARGS, (char *)"vdouble1d_t_pop_back(vdouble1d_t self)"},
 	 { (char *)"vdouble1d_t_erase", _wrap_vdouble1d_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< double >::iterator pos) -> std::vector< double >::iterator\n"
@@ -36347,10 +37186,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vdouble2d_t___nonzero__", _wrap_vdouble2d_t___nonzero__, METH_VARARGS, (char *)"vdouble2d_t___nonzero__(vdouble2d_t self) -> bool"},
 	 { (char *)"vdouble2d_t___bool__", _wrap_vdouble2d_t___bool__, METH_VARARGS, (char *)"vdouble2d_t___bool__(vdouble2d_t self) -> bool"},
 	 { (char *)"vdouble2d_t___len__", _wrap_vdouble2d_t___len__, METH_VARARGS, (char *)"vdouble2d_t___len__(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"},
+	 { (char *)"vdouble2d_t_pop", _wrap_vdouble2d_t_pop, METH_VARARGS, (char *)"vdouble2d_t_pop(vdouble2d_t self) -> vdouble1d_t"},
 	 { (char *)"vdouble2d_t___getslice__", _wrap_vdouble2d_t___getslice__, METH_VARARGS, (char *)"vdouble2d_t___getslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> vdouble2d_t"},
 	 { (char *)"vdouble2d_t___setslice__", _wrap_vdouble2d_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)\n"
-		"vdouble2d_t___setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, vdouble2d_t v)\n"
+		"__setslice__(std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, vdouble2d_t v)\n"
+		"vdouble2d_t___setslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)\n"
 		""},
 	 { (char *)"vdouble2d_t___delslice__", _wrap_vdouble2d_t___delslice__, METH_VARARGS, (char *)"vdouble2d_t___delslice__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"},
 	 { (char *)"vdouble2d_t___delitem__", _wrap_vdouble2d_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -36366,17 +37206,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vdouble2d_t___setitem__(vdouble2d_t self, std::vector< std::vector< double > >::difference_type i, vdouble1d_t x)\n"
 		""},
-	 { (char *)"vdouble2d_t_pop", _wrap_vdouble2d_t_pop, METH_VARARGS, (char *)"vdouble2d_t_pop(vdouble2d_t self) -> vdouble1d_t"},
 	 { (char *)"vdouble2d_t_append", _wrap_vdouble2d_t_append, METH_VARARGS, (char *)"vdouble2d_t_append(vdouble2d_t self, vdouble1d_t x)"},
 	 { (char *)"vdouble2d_t_empty", _wrap_vdouble2d_t_empty, METH_VARARGS, (char *)"vdouble2d_t_empty(vdouble2d_t self) -> bool"},
 	 { (char *)"vdouble2d_t_size", _wrap_vdouble2d_t_size, METH_VARARGS, (char *)"vdouble2d_t_size(vdouble2d_t self) -> std::vector< std::vector< double > >::size_type"},
+	 { (char *)"vdouble2d_t_clear", _wrap_vdouble2d_t_clear, METH_VARARGS, (char *)"vdouble2d_t_clear(vdouble2d_t self)"},
 	 { (char *)"vdouble2d_t_swap", _wrap_vdouble2d_t_swap, METH_VARARGS, (char *)"vdouble2d_t_swap(vdouble2d_t self, vdouble2d_t v)"},
+	 { (char *)"vdouble2d_t_get_allocator", _wrap_vdouble2d_t_get_allocator, METH_VARARGS, (char *)"vdouble2d_t_get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"},
 	 { (char *)"vdouble2d_t_begin", _wrap_vdouble2d_t_begin, METH_VARARGS, (char *)"vdouble2d_t_begin(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"},
 	 { (char *)"vdouble2d_t_end", _wrap_vdouble2d_t_end, METH_VARARGS, (char *)"vdouble2d_t_end(vdouble2d_t self) -> std::vector< std::vector< double > >::iterator"},
 	 { (char *)"vdouble2d_t_rbegin", _wrap_vdouble2d_t_rbegin, METH_VARARGS, (char *)"vdouble2d_t_rbegin(vdouble2d_t self) -> std::vector< std::vector< double > >::reverse_iterator"},
 	 { (char *)"vdouble2d_t_rend", _wrap_vdouble2d_t_rend, METH_VARARGS, (char *)"vdouble2d_t_rend(vdouble2d_t self) -> std::vector< std::vector< double > >::reverse_iterator"},
-	 { (char *)"vdouble2d_t_clear", _wrap_vdouble2d_t_clear, METH_VARARGS, (char *)"vdouble2d_t_clear(vdouble2d_t self)"},
-	 { (char *)"vdouble2d_t_get_allocator", _wrap_vdouble2d_t_get_allocator, METH_VARARGS, (char *)"vdouble2d_t_get_allocator(vdouble2d_t self) -> std::vector< std::vector< double > >::allocator_type"},
 	 { (char *)"vdouble2d_t_pop_back", _wrap_vdouble2d_t_pop_back, METH_VARARGS, (char *)"vdouble2d_t_pop_back(vdouble2d_t self)"},
 	 { (char *)"vdouble2d_t_erase", _wrap_vdouble2d_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< std::vector< double > >::iterator pos) -> std::vector< std::vector< double > >::iterator\n"
@@ -36408,10 +37247,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_integer_t___nonzero__", _wrap_vector_integer_t___nonzero__, METH_VARARGS, (char *)"vector_integer_t___nonzero__(vector_integer_t self) -> bool"},
 	 { (char *)"vector_integer_t___bool__", _wrap_vector_integer_t___bool__, METH_VARARGS, (char *)"vector_integer_t___bool__(vector_integer_t self) -> bool"},
 	 { (char *)"vector_integer_t___len__", _wrap_vector_integer_t___len__, METH_VARARGS, (char *)"vector_integer_t___len__(vector_integer_t self) -> std::vector< int >::size_type"},
+	 { (char *)"vector_integer_t_pop", _wrap_vector_integer_t_pop, METH_VARARGS, (char *)"vector_integer_t_pop(vector_integer_t self) -> std::vector< int >::value_type"},
 	 { (char *)"vector_integer_t___getslice__", _wrap_vector_integer_t___getslice__, METH_VARARGS, (char *)"vector_integer_t___getslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> vector_integer_t"},
 	 { (char *)"vector_integer_t___setslice__", _wrap_vector_integer_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< int >::difference_type i, std::vector< int >::difference_type j)\n"
-		"vector_integer_t___setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, vector_integer_t v)\n"
+		"__setslice__(std::vector< int >::difference_type i, std::vector< int >::difference_type j, vector_integer_t v)\n"
+		"vector_integer_t___setslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)\n"
 		""},
 	 { (char *)"vector_integer_t___delslice__", _wrap_vector_integer_t___delslice__, METH_VARARGS, (char *)"vector_integer_t___delslice__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"},
 	 { (char *)"vector_integer_t___delitem__", _wrap_vector_integer_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -36427,17 +37267,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_integer_t___setitem__(vector_integer_t self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)\n"
 		""},
-	 { (char *)"vector_integer_t_pop", _wrap_vector_integer_t_pop, METH_VARARGS, (char *)"vector_integer_t_pop(vector_integer_t self) -> std::vector< int >::value_type"},
 	 { (char *)"vector_integer_t_append", _wrap_vector_integer_t_append, METH_VARARGS, (char *)"vector_integer_t_append(vector_integer_t self, std::vector< int >::value_type const & x)"},
 	 { (char *)"vector_integer_t_empty", _wrap_vector_integer_t_empty, METH_VARARGS, (char *)"vector_integer_t_empty(vector_integer_t self) -> bool"},
 	 { (char *)"vector_integer_t_size", _wrap_vector_integer_t_size, METH_VARARGS, (char *)"vector_integer_t_size(vector_integer_t self) -> std::vector< int >::size_type"},
+	 { (char *)"vector_integer_t_clear", _wrap_vector_integer_t_clear, METH_VARARGS, (char *)"vector_integer_t_clear(vector_integer_t self)"},
 	 { (char *)"vector_integer_t_swap", _wrap_vector_integer_t_swap, METH_VARARGS, (char *)"vector_integer_t_swap(vector_integer_t self, vector_integer_t v)"},
+	 { (char *)"vector_integer_t_get_allocator", _wrap_vector_integer_t_get_allocator, METH_VARARGS, (char *)"vector_integer_t_get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"},
 	 { (char *)"vector_integer_t_begin", _wrap_vector_integer_t_begin, METH_VARARGS, (char *)"vector_integer_t_begin(vector_integer_t self) -> std::vector< int >::iterator"},
 	 { (char *)"vector_integer_t_end", _wrap_vector_integer_t_end, METH_VARARGS, (char *)"vector_integer_t_end(vector_integer_t self) -> std::vector< int >::iterator"},
 	 { (char *)"vector_integer_t_rbegin", _wrap_vector_integer_t_rbegin, METH_VARARGS, (char *)"vector_integer_t_rbegin(vector_integer_t self) -> std::vector< int >::reverse_iterator"},
 	 { (char *)"vector_integer_t_rend", _wrap_vector_integer_t_rend, METH_VARARGS, (char *)"vector_integer_t_rend(vector_integer_t self) -> std::vector< int >::reverse_iterator"},
-	 { (char *)"vector_integer_t_clear", _wrap_vector_integer_t_clear, METH_VARARGS, (char *)"vector_integer_t_clear(vector_integer_t self)"},
-	 { (char *)"vector_integer_t_get_allocator", _wrap_vector_integer_t_get_allocator, METH_VARARGS, (char *)"vector_integer_t_get_allocator(vector_integer_t self) -> std::vector< int >::allocator_type"},
 	 { (char *)"vector_integer_t_pop_back", _wrap_vector_integer_t_pop_back, METH_VARARGS, (char *)"vector_integer_t_pop_back(vector_integer_t self)"},
 	 { (char *)"vector_integer_t_erase", _wrap_vector_integer_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< int >::iterator pos) -> std::vector< int >::iterator\n"
@@ -36469,10 +37308,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_longinteger_t___nonzero__", _wrap_vector_longinteger_t___nonzero__, METH_VARARGS, (char *)"vector_longinteger_t___nonzero__(vector_longinteger_t self) -> bool"},
 	 { (char *)"vector_longinteger_t___bool__", _wrap_vector_longinteger_t___bool__, METH_VARARGS, (char *)"vector_longinteger_t___bool__(vector_longinteger_t self) -> bool"},
 	 { (char *)"vector_longinteger_t___len__", _wrap_vector_longinteger_t___len__, METH_VARARGS, (char *)"vector_longinteger_t___len__(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"},
+	 { (char *)"vector_longinteger_t_pop", _wrap_vector_longinteger_t_pop, METH_VARARGS, (char *)"vector_longinteger_t_pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"},
 	 { (char *)"vector_longinteger_t___getslice__", _wrap_vector_longinteger_t___getslice__, METH_VARARGS, (char *)"vector_longinteger_t___getslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j) -> vector_longinteger_t"},
 	 { (char *)"vector_longinteger_t___setslice__", _wrap_vector_longinteger_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)\n"
-		"vector_longinteger_t___setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, vector_longinteger_t v)\n"
+		"__setslice__(std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j, vector_longinteger_t v)\n"
+		"vector_longinteger_t___setslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)\n"
 		""},
 	 { (char *)"vector_longinteger_t___delslice__", _wrap_vector_longinteger_t___delslice__, METH_VARARGS, (char *)"vector_longinteger_t___delslice__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::difference_type j)"},
 	 { (char *)"vector_longinteger_t___delitem__", _wrap_vector_longinteger_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -36488,17 +37328,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_longinteger_t___setitem__(vector_longinteger_t self, std::vector< unsigned long >::difference_type i, std::vector< unsigned long >::value_type const & x)\n"
 		""},
-	 { (char *)"vector_longinteger_t_pop", _wrap_vector_longinteger_t_pop, METH_VARARGS, (char *)"vector_longinteger_t_pop(vector_longinteger_t self) -> std::vector< unsigned long >::value_type"},
 	 { (char *)"vector_longinteger_t_append", _wrap_vector_longinteger_t_append, METH_VARARGS, (char *)"vector_longinteger_t_append(vector_longinteger_t self, std::vector< unsigned long >::value_type const & x)"},
 	 { (char *)"vector_longinteger_t_empty", _wrap_vector_longinteger_t_empty, METH_VARARGS, (char *)"vector_longinteger_t_empty(vector_longinteger_t self) -> bool"},
 	 { (char *)"vector_longinteger_t_size", _wrap_vector_longinteger_t_size, METH_VARARGS, (char *)"vector_longinteger_t_size(vector_longinteger_t self) -> std::vector< unsigned long >::size_type"},
+	 { (char *)"vector_longinteger_t_clear", _wrap_vector_longinteger_t_clear, METH_VARARGS, (char *)"vector_longinteger_t_clear(vector_longinteger_t self)"},
 	 { (char *)"vector_longinteger_t_swap", _wrap_vector_longinteger_t_swap, METH_VARARGS, (char *)"vector_longinteger_t_swap(vector_longinteger_t self, vector_longinteger_t v)"},
+	 { (char *)"vector_longinteger_t_get_allocator", _wrap_vector_longinteger_t_get_allocator, METH_VARARGS, (char *)"vector_longinteger_t_get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"},
 	 { (char *)"vector_longinteger_t_begin", _wrap_vector_longinteger_t_begin, METH_VARARGS, (char *)"vector_longinteger_t_begin(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"},
 	 { (char *)"vector_longinteger_t_end", _wrap_vector_longinteger_t_end, METH_VARARGS, (char *)"vector_longinteger_t_end(vector_longinteger_t self) -> std::vector< unsigned long >::iterator"},
 	 { (char *)"vector_longinteger_t_rbegin", _wrap_vector_longinteger_t_rbegin, METH_VARARGS, (char *)"vector_longinteger_t_rbegin(vector_longinteger_t self) -> std::vector< unsigned long >::reverse_iterator"},
 	 { (char *)"vector_longinteger_t_rend", _wrap_vector_longinteger_t_rend, METH_VARARGS, (char *)"vector_longinteger_t_rend(vector_longinteger_t self) -> std::vector< unsigned long >::reverse_iterator"},
-	 { (char *)"vector_longinteger_t_clear", _wrap_vector_longinteger_t_clear, METH_VARARGS, (char *)"vector_longinteger_t_clear(vector_longinteger_t self)"},
-	 { (char *)"vector_longinteger_t_get_allocator", _wrap_vector_longinteger_t_get_allocator, METH_VARARGS, (char *)"vector_longinteger_t_get_allocator(vector_longinteger_t self) -> std::vector< unsigned long >::allocator_type"},
 	 { (char *)"vector_longinteger_t_pop_back", _wrap_vector_longinteger_t_pop_back, METH_VARARGS, (char *)"vector_longinteger_t_pop_back(vector_longinteger_t self)"},
 	 { (char *)"vector_longinteger_t_erase", _wrap_vector_longinteger_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< unsigned long >::iterator pos) -> std::vector< unsigned long >::iterator\n"
@@ -36530,10 +37369,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_complex_t___nonzero__", _wrap_vector_complex_t___nonzero__, METH_VARARGS, (char *)"vector_complex_t___nonzero__(vector_complex_t self) -> bool"},
 	 { (char *)"vector_complex_t___bool__", _wrap_vector_complex_t___bool__, METH_VARARGS, (char *)"vector_complex_t___bool__(vector_complex_t self) -> bool"},
 	 { (char *)"vector_complex_t___len__", _wrap_vector_complex_t___len__, METH_VARARGS, (char *)"vector_complex_t___len__(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"},
+	 { (char *)"vector_complex_t_pop", _wrap_vector_complex_t_pop, METH_VARARGS, (char *)"vector_complex_t_pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"},
 	 { (char *)"vector_complex_t___getslice__", _wrap_vector_complex_t___getslice__, METH_VARARGS, (char *)"vector_complex_t___getslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j) -> vector_complex_t"},
 	 { (char *)"vector_complex_t___setslice__", _wrap_vector_complex_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)\n"
-		"vector_complex_t___setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, vector_complex_t v)\n"
+		"__setslice__(std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j, vector_complex_t v)\n"
+		"vector_complex_t___setslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)\n"
 		""},
 	 { (char *)"vector_complex_t___delslice__", _wrap_vector_complex_t___delslice__, METH_VARARGS, (char *)"vector_complex_t___delslice__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::difference_type j)"},
 	 { (char *)"vector_complex_t___delitem__", _wrap_vector_complex_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -36549,17 +37389,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_complex_t___setitem__(vector_complex_t self, std::vector< std::complex< double > >::difference_type i, std::vector< std::complex< double > >::value_type const & x)\n"
 		""},
-	 { (char *)"vector_complex_t_pop", _wrap_vector_complex_t_pop, METH_VARARGS, (char *)"vector_complex_t_pop(vector_complex_t self) -> std::vector< std::complex< double > >::value_type"},
 	 { (char *)"vector_complex_t_append", _wrap_vector_complex_t_append, METH_VARARGS, (char *)"vector_complex_t_append(vector_complex_t self, std::vector< std::complex< double > >::value_type const & x)"},
 	 { (char *)"vector_complex_t_empty", _wrap_vector_complex_t_empty, METH_VARARGS, (char *)"vector_complex_t_empty(vector_complex_t self) -> bool"},
 	 { (char *)"vector_complex_t_size", _wrap_vector_complex_t_size, METH_VARARGS, (char *)"vector_complex_t_size(vector_complex_t self) -> std::vector< std::complex< double > >::size_type"},
+	 { (char *)"vector_complex_t_clear", _wrap_vector_complex_t_clear, METH_VARARGS, (char *)"vector_complex_t_clear(vector_complex_t self)"},
 	 { (char *)"vector_complex_t_swap", _wrap_vector_complex_t_swap, METH_VARARGS, (char *)"vector_complex_t_swap(vector_complex_t self, vector_complex_t v)"},
+	 { (char *)"vector_complex_t_get_allocator", _wrap_vector_complex_t_get_allocator, METH_VARARGS, (char *)"vector_complex_t_get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"},
 	 { (char *)"vector_complex_t_begin", _wrap_vector_complex_t_begin, METH_VARARGS, (char *)"vector_complex_t_begin(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"},
 	 { (char *)"vector_complex_t_end", _wrap_vector_complex_t_end, METH_VARARGS, (char *)"vector_complex_t_end(vector_complex_t self) -> std::vector< std::complex< double > >::iterator"},
 	 { (char *)"vector_complex_t_rbegin", _wrap_vector_complex_t_rbegin, METH_VARARGS, (char *)"vector_complex_t_rbegin(vector_complex_t self) -> std::vector< std::complex< double > >::reverse_iterator"},
 	 { (char *)"vector_complex_t_rend", _wrap_vector_complex_t_rend, METH_VARARGS, (char *)"vector_complex_t_rend(vector_complex_t self) -> std::vector< std::complex< double > >::reverse_iterator"},
-	 { (char *)"vector_complex_t_clear", _wrap_vector_complex_t_clear, METH_VARARGS, (char *)"vector_complex_t_clear(vector_complex_t self)"},
-	 { (char *)"vector_complex_t_get_allocator", _wrap_vector_complex_t_get_allocator, METH_VARARGS, (char *)"vector_complex_t_get_allocator(vector_complex_t self) -> std::vector< std::complex< double > >::allocator_type"},
 	 { (char *)"vector_complex_t_pop_back", _wrap_vector_complex_t_pop_back, METH_VARARGS, (char *)"vector_complex_t_pop_back(vector_complex_t self)"},
 	 { (char *)"vector_complex_t_erase", _wrap_vector_complex_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< std::complex< double > >::iterator pos) -> std::vector< std::complex< double > >::iterator\n"
@@ -36591,10 +37430,11 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"vector_string_t___nonzero__", _wrap_vector_string_t___nonzero__, METH_VARARGS, (char *)"vector_string_t___nonzero__(vector_string_t self) -> bool"},
 	 { (char *)"vector_string_t___bool__", _wrap_vector_string_t___bool__, METH_VARARGS, (char *)"vector_string_t___bool__(vector_string_t self) -> bool"},
 	 { (char *)"vector_string_t___len__", _wrap_vector_string_t___len__, METH_VARARGS, (char *)"vector_string_t___len__(vector_string_t self) -> std::vector< std::string >::size_type"},
+	 { (char *)"vector_string_t_pop", _wrap_vector_string_t_pop, METH_VARARGS, (char *)"vector_string_t_pop(vector_string_t self) -> std::vector< std::string >::value_type"},
 	 { (char *)"vector_string_t___getslice__", _wrap_vector_string_t___getslice__, METH_VARARGS, (char *)"vector_string_t___getslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> vector_string_t"},
 	 { (char *)"vector_string_t___setslice__", _wrap_vector_string_t___setslice__, METH_VARARGS, (char *)"\n"
-		"__setslice__(std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)\n"
-		"vector_string_t___setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, vector_string_t v)\n"
+		"__setslice__(std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, vector_string_t v)\n"
+		"vector_string_t___setslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)\n"
 		""},
 	 { (char *)"vector_string_t___delslice__", _wrap_vector_string_t___delslice__, METH_VARARGS, (char *)"vector_string_t___delslice__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"},
 	 { (char *)"vector_string_t___delitem__", _wrap_vector_string_t___delitem__, METH_VARARGS, (char *)"\n"
@@ -36610,17 +37450,16 @@ static PyMethodDef SwigMethods[] = {
 		"__setitem__(PySliceObject * slice)\n"
 		"vector_string_t___setitem__(vector_string_t self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)\n"
 		""},
-	 { (char *)"vector_string_t_pop", _wrap_vector_string_t_pop, METH_VARARGS, (char *)"vector_string_t_pop(vector_string_t self) -> std::vector< std::string >::value_type"},
 	 { (char *)"vector_string_t_append", _wrap_vector_string_t_append, METH_VARARGS, (char *)"vector_string_t_append(vector_string_t self, std::vector< std::string >::value_type const & x)"},
 	 { (char *)"vector_string_t_empty", _wrap_vector_string_t_empty, METH_VARARGS, (char *)"vector_string_t_empty(vector_string_t self) -> bool"},
 	 { (char *)"vector_string_t_size", _wrap_vector_string_t_size, METH_VARARGS, (char *)"vector_string_t_size(vector_string_t self) -> std::vector< std::string >::size_type"},
+	 { (char *)"vector_string_t_clear", _wrap_vector_string_t_clear, METH_VARARGS, (char *)"vector_string_t_clear(vector_string_t self)"},
 	 { (char *)"vector_string_t_swap", _wrap_vector_string_t_swap, METH_VARARGS, (char *)"vector_string_t_swap(vector_string_t self, vector_string_t v)"},
+	 { (char *)"vector_string_t_get_allocator", _wrap_vector_string_t_get_allocator, METH_VARARGS, (char *)"vector_string_t_get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"},
 	 { (char *)"vector_string_t_begin", _wrap_vector_string_t_begin, METH_VARARGS, (char *)"vector_string_t_begin(vector_string_t self) -> std::vector< std::string >::iterator"},
 	 { (char *)"vector_string_t_end", _wrap_vector_string_t_end, METH_VARARGS, (char *)"vector_string_t_end(vector_string_t self) -> std::vector< std::string >::iterator"},
 	 { (char *)"vector_string_t_rbegin", _wrap_vector_string_t_rbegin, METH_VARARGS, (char *)"vector_string_t_rbegin(vector_string_t self) -> std::vector< std::string >::reverse_iterator"},
 	 { (char *)"vector_string_t_rend", _wrap_vector_string_t_rend, METH_VARARGS, (char *)"vector_string_t_rend(vector_string_t self) -> std::vector< std::string >::reverse_iterator"},
-	 { (char *)"vector_string_t_clear", _wrap_vector_string_t_clear, METH_VARARGS, (char *)"vector_string_t_clear(vector_string_t self)"},
-	 { (char *)"vector_string_t_get_allocator", _wrap_vector_string_t_get_allocator, METH_VARARGS, (char *)"vector_string_t_get_allocator(vector_string_t self) -> std::vector< std::string >::allocator_type"},
 	 { (char *)"vector_string_t_pop_back", _wrap_vector_string_t_pop_back, METH_VARARGS, (char *)"vector_string_t_pop_back(vector_string_t self)"},
 	 { (char *)"vector_string_t_erase", _wrap_vector_string_t_erase, METH_VARARGS, (char *)"\n"
 		"erase(std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator\n"
@@ -38031,6 +38870,57 @@ static PyMethodDef SwigMethods[] = {
 		"\n"
 		""},
 	 { (char *)"MinimizerOptions_swigregister", MinimizerOptions_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_FitStrategyAdjustMinimizer", _wrap_new_FitStrategyAdjustMinimizer, METH_VARARGS, (char *)"\n"
+		"FitStrategyAdjustMinimizer()\n"
+		"FitStrategyAdjustMinimizer(std::string const & minimizer_name, std::string const & algorithm_name, std::string const & minimizer_options)\n"
+		"FitStrategyAdjustMinimizer(std::string const & minimizer_name, std::string const & algorithm_name)\n"
+		"new_FitStrategyAdjustMinimizer(PyObject * arg2, std::string const & minimizer_name) -> FitStrategyAdjustMinimizer\n"
+		"\n"
+		"FitStrategyAdjustMinimizer::FitStrategyAdjustMinimizer(const std::string &minimizer_name, const std::string &algorithm_name=std::string(), const std::string &minimizer_options=std::string())\n"
+		"\n"
+		""},
+	 { (char *)"delete_FitStrategyAdjustMinimizer", _wrap_delete_FitStrategyAdjustMinimizer, METH_VARARGS, (char *)"\n"
+		"delete_FitStrategyAdjustMinimizer(FitStrategyAdjustMinimizer self)\n"
+		"\n"
+		"FitStrategyAdjustMinimizer::~FitStrategyAdjustMinimizer()\n"
+		"\n"
+		""},
+	 { (char *)"FitStrategyAdjustMinimizer_clone", _wrap_FitStrategyAdjustMinimizer_clone, METH_VARARGS, (char *)"\n"
+		"FitStrategyAdjustMinimizer_clone(FitStrategyAdjustMinimizer self) -> FitStrategyAdjustMinimizer\n"
+		"\n"
+		"FitStrategyAdjustMinimizer * FitStrategyAdjustMinimizer::clone() const \n"
+		"\n"
+		""},
+	 { (char *)"FitStrategyAdjustMinimizer_getMinimizer", _wrap_FitStrategyAdjustMinimizer_getMinimizer, METH_VARARGS, (char *)"\n"
+		"FitStrategyAdjustMinimizer_getMinimizer(FitStrategyAdjustMinimizer self) -> IMinimizer\n"
+		"\n"
+		"IMinimizer * FitStrategyAdjustMinimizer::getMinimizer()\n"
+		"\n"
+		""},
+	 { (char *)"FitStrategyAdjustMinimizer_setMinimizer", _wrap_FitStrategyAdjustMinimizer_setMinimizer, METH_VARARGS, (char *)"\n"
+		"setMinimizer(IMinimizer minimizer)\n"
+		"setMinimizer(std::string const & minimizer_name, std::string const & algorithm_name, std::string const & minimizer_options)\n"
+		"setMinimizer(std::string const & minimizer_name, std::string const & algorithm_name)\n"
+		"FitStrategyAdjustMinimizer_setMinimizer(FitStrategyAdjustMinimizer self, std::string const & minimizer_name)\n"
+		"\n"
+		"void FitStrategyAdjustMinimizer::setMinimizer(const std::string &minimizer_name, const std::string &algorithm_name=std::string(), const std::string &minimizer_options=std::string())\n"
+		"\n"
+		""},
+	 { (char *)"FitStrategyAdjustMinimizer_execute", _wrap_FitStrategyAdjustMinimizer_execute, METH_VARARGS, (char *)"\n"
+		"FitStrategyAdjustMinimizer_execute(FitStrategyAdjustMinimizer self)\n"
+		"\n"
+		"void FitStrategyAdjustMinimizer::execute()\n"
+		"\n"
+		""},
+	 { (char *)"FitStrategyAdjustMinimizer_getMinimizerOptions", _wrap_FitStrategyAdjustMinimizer_getMinimizerOptions, METH_VARARGS, (char *)"\n"
+		"FitStrategyAdjustMinimizer_getMinimizerOptions(FitStrategyAdjustMinimizer self) -> MinimizerOptions\n"
+		"\n"
+		"MinimizerOptions * FitStrategyAdjustMinimizer::getMinimizerOptions()\n"
+		"\n"
+		""},
+	 { (char *)"FitStrategyAdjustMinimizer__print", _wrap_FitStrategyAdjustMinimizer__print, METH_VARARGS, (char *)"FitStrategyAdjustMinimizer__print(FitStrategyAdjustMinimizer self, std::ostream & ostr)"},
+	 { (char *)"disown_FitStrategyAdjustMinimizer", _wrap_disown_FitStrategyAdjustMinimizer, METH_VARARGS, NULL},
+	 { (char *)"FitStrategyAdjustMinimizer_swigregister", FitStrategyAdjustMinimizer_swigregister, METH_VARARGS, NULL},
 	 { NULL, NULL, 0, NULL }
 };
 
@@ -38086,6 +38976,9 @@ static void *_p_IFitObserverTo_p_IObserver(void *x, int *SWIGUNUSEDPARM(newmemor
 static void *_p_FitStrategyDefaultTo_p_IFitStrategy(void *x, int *SWIGUNUSEDPARM(newmemory)) {
     return (void *)((IFitStrategy *)  ((FitStrategyDefault *) x));
 }
+static void *_p_FitStrategyAdjustMinimizerTo_p_IFitStrategy(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((IFitStrategy *)  ((FitStrategyAdjustMinimizer *) x));
+}
 static void *_p_FitObjectTo_p_IParameterized(void *x, int *SWIGUNUSEDPARM(newmemory)) {
     return (void *)((IParameterized *)  ((FitObject *) x));
 }
@@ -38128,6 +39021,9 @@ static void *_p_IntensityNormalizerTo_p_INamed(void *x, int *SWIGUNUSEDPARM(newm
 static void *_p_IntensityScaleAndShiftNormalizerTo_p_INamed(void *x, int *SWIGUNUSEDPARM(newmemory)) {
     return (void *)((INamed *) (IParameterized *)(IIntensityNormalizer *)(IntensityNormalizer *) ((IntensityScaleAndShiftNormalizer *) x));
 }
+static void *_p_FitStrategyAdjustMinimizerTo_p_INamed(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((INamed *) (IFitStrategy *) ((FitStrategyAdjustMinimizer *) x));
+}
 static void *_p_IChiSquaredModuleTo_p_ICloneable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
     return (void *)((ICloneable *)  ((IChiSquaredModule *) x));
 }
@@ -38141,6 +39037,7 @@ static swig_type_info _swigt__p_FitObject = {"_p_FitObject", "FitObject *", 0, 0
 static swig_type_info _swigt__p_FitObjects_t = {"_p_FitObjects_t", "FitObjects_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_FitOptions = {"_p_FitOptions", "FitOptions *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_FitParameter = {"_p_FitParameter", "FitParameter *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_FitStrategyAdjustMinimizer = {"_p_FitStrategyAdjustMinimizer", "FitStrategyAdjustMinimizer *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_FitStrategyDefault = {"_p_FitStrategyDefault", "FitStrategyDefault *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_FitSuite = {"_p_FitSuite", "FitSuite *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_FitSuiteObjects = {"_p_FitSuiteObjects", "FitSuiteObjects *", 0, 0, (void*)0, 0};
@@ -38229,6 +39126,7 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_FitObjects_t,
   &_swigt__p_FitOptions,
   &_swigt__p_FitParameter,
+  &_swigt__p_FitStrategyAdjustMinimizer,
   &_swigt__p_FitStrategyDefault,
   &_swigt__p_FitSuite,
   &_swigt__p_FitSuiteObjects,
@@ -38317,6 +39215,7 @@ static swig_cast_info _swigc__p_FitObject[] = {  {&_swigt__p_FitObject, 0, 0, 0}
 static swig_cast_info _swigc__p_FitObjects_t[] = {  {&_swigt__p_FitObjects_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_FitOptions[] = {  {&_swigt__p_FitOptions, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_FitParameter[] = {  {&_swigt__p_FitParameter, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_FitStrategyAdjustMinimizer[] = {  {&_swigt__p_FitStrategyAdjustMinimizer, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_FitStrategyDefault[] = {  {&_swigt__p_FitStrategyDefault, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_FitSuite[] = {  {&_swigt__p_FitSuite, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_FitSuiteObjects[] = {  {&_swigt__p_FitSuiteObjects, 0, 0, 0},{0, 0, 0, 0}};
@@ -38326,12 +39225,12 @@ static swig_cast_info _swigc__p_GISASSimulation[] = {  {&_swigt__p_GISASSimulati
 static swig_cast_info _swigc__p_IChiSquaredModule[] = {  {&_swigt__p_IChiSquaredModule, 0, 0, 0},  {&_swigt__p_ChiSquaredModule, _p_ChiSquaredModuleTo_p_IChiSquaredModule, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_ICloneable[] = {  {&_swigt__p_IChiSquaredModule, _p_IChiSquaredModuleTo_p_ICloneable, 0, 0},  {&_swigt__p_ChiSquaredModule, _p_ChiSquaredModuleTo_p_ICloneable, 0, 0},  {&_swigt__p_ICloneable, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_IFitObserver[] = {  {&_swigt__p_IFitObserver, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_IFitStrategy[] = {  {&_swigt__p_IFitStrategy, 0, 0, 0},  {&_swigt__p_FitStrategyDefault, _p_FitStrategyDefaultTo_p_IFitStrategy, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_IFitStrategy[] = {  {&_swigt__p_IFitStrategy, 0, 0, 0},  {&_swigt__p_FitStrategyDefault, _p_FitStrategyDefaultTo_p_IFitStrategy, 0, 0},  {&_swigt__p_FitStrategyAdjustMinimizer, _p_FitStrategyAdjustMinimizerTo_p_IFitStrategy, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_IHistogram[] = {  {&_swigt__p_IHistogram, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_IIntensityFunction[] = {  {&_swigt__p_IntensityFunctionSqrt, _p_IntensityFunctionSqrtTo_p_IIntensityFunction, 0, 0},  {&_swigt__p_IIntensityFunction, 0, 0, 0},  {&_swigt__p_IntensityFunctionLog, _p_IntensityFunctionLogTo_p_IIntensityFunction, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_IIntensityNormalizer[] = {  {&_swigt__p_IIntensityNormalizer, 0, 0, 0},  {&_swigt__p_IntensityNormalizer, _p_IntensityNormalizerTo_p_IIntensityNormalizer, 0, 0},  {&_swigt__p_IntensityScaleAndShiftNormalizer, _p_IntensityScaleAndShiftNormalizerTo_p_IIntensityNormalizer, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_IMinimizer[] = {  {&_swigt__p_IMinimizer, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_INamed[] = {  {&_swigt__p_INamed, 0, 0, 0},  {&_swigt__p_IFitStrategy, _p_IFitStrategyTo_p_INamed, 0, 0},  {&_swigt__p_FitParameter, _p_FitParameterTo_p_INamed, 0, 0},  {&_swigt__p_FitStrategyDefault, _p_FitStrategyDefaultTo_p_INamed, 0, 0},  {&_swigt__p_FitObject, _p_FitObjectTo_p_INamed, 0, 0},  {&_swigt__p_IParameterized, _p_IParameterizedTo_p_INamed, 0, 0},  {&_swigt__p_FitSuiteObjects, _p_FitSuiteObjectsTo_p_INamed, 0, 0},  {&_swigt__p_IIntensityNormalizer, _p_IIntensityNormalizerTo_p_INamed, 0, 0},  {&_swigt__p_IntensityNormalizer, _p_IntensityNormalizerTo_p_INamed, 0, 0},  {&_swigt__p_IntensityScaleAndShiftNormalizer, _p_IntensityScaleAndShiftNormalizerTo_p_INamed, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_INamed[] = {  {&_swigt__p_INamed, 0, 0, 0},  {&_swigt__p_IFitStrategy, _p_IFitStrategyTo_p_INamed, 0, 0},  {&_swigt__p_FitParameter, _p_FitParameterTo_p_INamed, 0, 0},  {&_swigt__p_FitStrategyDefault, _p_FitStrategyDefaultTo_p_INamed, 0, 0},  {&_swigt__p_FitObject, _p_FitObjectTo_p_INamed, 0, 0},  {&_swigt__p_IParameterized, _p_IParameterizedTo_p_INamed, 0, 0},  {&_swigt__p_FitSuiteObjects, _p_FitSuiteObjectsTo_p_INamed, 0, 0},  {&_swigt__p_FitStrategyAdjustMinimizer, _p_FitStrategyAdjustMinimizerTo_p_INamed, 0, 0},  {&_swigt__p_IIntensityNormalizer, _p_IIntensityNormalizerTo_p_INamed, 0, 0},  {&_swigt__p_IntensityNormalizer, _p_IntensityNormalizerTo_p_INamed, 0, 0},  {&_swigt__p_IntensityScaleAndShiftNormalizer, _p_IntensityScaleAndShiftNormalizerTo_p_INamed, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_IObservable[] = {  {&_swigt__p_IObservable, 0, 0, 0},  {&_swigt__p_FitSuite, _p_FitSuiteTo_p_IObservable, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_IObserver[] = {  {&_swigt__p_IObserver, 0, 0, 0},  {&_swigt__p_IFitObserver, _p_IFitObserverTo_p_IObserver, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_IParameterized[] = {  {&_swigt__p_FitObject, _p_FitObjectTo_p_IParameterized, 0, 0},  {&_swigt__p_IParameterized, 0, 0, 0},  {&_swigt__p_FitSuiteObjects, _p_FitSuiteObjectsTo_p_IParameterized, 0, 0},  {&_swigt__p_IIntensityNormalizer, _p_IIntensityNormalizerTo_p_IParameterized, 0, 0},  {&_swigt__p_IntensityNormalizer, _p_IntensityNormalizerTo_p_IParameterized, 0, 0},  {&_swigt__p_IntensityScaleAndShiftNormalizer, _p_IntensityScaleAndShiftNormalizerTo_p_IParameterized, 0, 0},{0, 0, 0, 0}};
@@ -38405,6 +39304,7 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_FitObjects_t,
   _swigc__p_FitOptions,
   _swigc__p_FitParameter,
+  _swigc__p_FitStrategyAdjustMinimizer,
   _swigc__p_FitStrategyDefault,
   _swigc__p_FitSuite,
   _swigc__p_FitSuiteObjects,
@@ -38901,19 +39801,10 @@ extern "C" {
         0,                                  /* tp_del */
 #endif
 #if PY_VERSION_HEX >= 0x02060000
-        0,                                  /* tp_version_tag */
-#endif
-#if PY_VERSION_HEX >= 0x03040000
-        0,                                  /* tp_finalize */
+        0,                                  /* tp_version */
 #endif
 #ifdef COUNT_ALLOCS
-        0,                                  /* tp_allocs */
-        0,                                  /* tp_frees */
-        0,                                  /* tp_maxalloc */
-#if PY_VERSION_HEX >= 0x02050000
-        0,                                  /* tp_prev */
-#endif
-        0                                   /* tp_next */
+        0,0,0,0                             /* tp_alloc -> tp_next */
 #endif
       };
       varlink_type = tmp;
diff --git a/Fit/PythonAPI/libBornAgainFit_wrap.h b/Fit/PythonAPI/libBornAgainFit_wrap.h
index 10619dde2e627d83d53e9a7d5b57864526534e31..39cb4f44807654a58249bc798ec53fe2e202c27a 100644
--- a/Fit/PythonAPI/libBornAgainFit_wrap.h
+++ b/Fit/PythonAPI/libBornAgainFit_wrap.h
@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 3.0.8
+ * Version 3.0.7
  *
  * This file is not intended to be easily readable and contains a number of
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -1084,4 +1084,54 @@ private:
 };
 
 
+class SwigDirector_FitStrategyAdjustMinimizer : public FitStrategyAdjustMinimizer, public Swig::Director {
+
+public:
+    SwigDirector_FitStrategyAdjustMinimizer(PyObject *self);
+    SwigDirector_FitStrategyAdjustMinimizer(PyObject *self, std::string const &minimizer_name, std::string const &algorithm_name = std::string(), std::string const &minimizer_options = std::string());
+    virtual ~SwigDirector_FitStrategyAdjustMinimizer();
+    virtual FitStrategyAdjustMinimizer *clone() const;
+    virtual void init(FitKernel *fit_suite);
+    virtual void execute();
+    virtual void print(std::ostream &ostr) const;
+    virtual void printSwigPublic(std::ostream &ostr) const {
+      FitStrategyAdjustMinimizer::print(ostr);
+    }
+    virtual MinimizerOptions *getMinimizerOptions();
+
+/* Internal director utilities */
+public:
+    bool swig_get_inner(const char *swig_protected_method_name) const {
+      std::map<std::string, bool>::const_iterator iv = swig_inner.find(swig_protected_method_name);
+      return (iv != swig_inner.end() ? iv->second : false);
+    }
+    void swig_set_inner(const char *swig_protected_method_name, bool swig_val) const {
+      swig_inner[swig_protected_method_name] = swig_val;
+    }
+private:
+    mutable std::map<std::string, bool> swig_inner;
+
+#if defined(SWIG_PYTHON_DIRECTOR_VTABLE)
+/* VTable implementation */
+    PyObject *swig_get_method(size_t method_index, const char *method_name) const {
+      PyObject *method = vtable[method_index];
+      if (!method) {
+        swig::SwigVar_PyObject name = SWIG_Python_str_FromChar(method_name);
+        method = PyObject_GetAttr(swig_get_self(), name);
+        if (!method) {
+          std::string msg = "Method in class FitStrategyAdjustMinimizer doesn't exist, undefined ";
+          msg += method_name;
+          Swig::DirectorMethodException::raise(msg.c_str());
+        }
+        vtable[method_index] = method;
+      }
+      return method;
+    }
+private:
+    mutable swig::SwigVar_PyObject vtable[5];
+#endif
+
+};
+
+
 #endif
diff --git a/cmake/modules/SearchInstalledSoftware.cmake b/cmake/modules/SearchInstalledSoftware.cmake
index dc6953110f05eb428e3917c2c0d2d2e354f9e391..eb30f9b24f1da8c93bafebc1069abc52873971ba 100644
--- a/cmake/modules/SearchInstalledSoftware.cmake
+++ b/cmake/modules/SearchInstalledSoftware.cmake
@@ -6,7 +6,7 @@ if (BORNAGAIN_GENERATE_BINDINGS AND BORNAGAIN_GENERATE_PYTHON_DOCS)
 endif()
 
 if (BORNAGAIN_USE_PYTHON3)
-  set(Python_ADDITIONAL_VERSIONS 3.5)
+  set(Python_ADDITIONAL_VERSIONS 3.5 3.4 3.3)
 else()
   set(Python_ADDITIONAL_VERSIONS 2.7)
 endif()
@@ -34,20 +34,12 @@ if(WIN32)
 else()
     set(boost_libraries_required date_time chrono program_options iostreams system filesystem regex thread)
 endif()
-if(BORNAGAIN_PYTHON OR BORNAGAIN_GUI)
-  if(BORNAGAIN_USE_PYTHON3)
-    list(APPEND boost_libraries_required)
-  else()
-    list(APPEND boost_libraries_required)
-  endif()
-endif()
 find_package(Boost 1.48.0 COMPONENTS ${boost_libraries_required} REQUIRED)
 message(STATUS "Boost_INCLUDE_DIRS: ${Boost_INCLUDE_DIRS}")
 message(STATUS "Boost_LIBRARY_DIRS: ${Boost_LIBRARY_DIRS}")
 message(STATUS "Boost_LIBRARIES: ${Boost_LIBRARIES}")
 
 
-
 # --- GSL ---
 find_package(GSL REQUIRED)
 
@@ -66,20 +58,13 @@ endif()
 
 # --- Python ---
 if(BORNAGAIN_PYTHON OR BORNAGAIN_GUI)
-
-
-
-    # testing Python 3
-    #find_package(PythonInterp 2.7 REQUIRED)
     find_package(PythonInterp REQUIRED)
     message(STATUS "--> PYTHON_VERSION_STRING: ${PYTHON_VERSION_STRING}, PYTHON_EXECUTABLE:${PYTHON_EXECUTABLE}")
 
-    # testing Python 3
-    #find_package(PythonLibs 2.7)
     find_package(PythonLibs REQUIRED)
     message(STATUS "--> PYTHON_LIBRARIES: ${PYTHON_LIBRARIES}, PYTHON_INCLUDE_DIRS:${PYTHON_INCLUDE_DIRS} PYTHONLIBS_VERSION_STRING:${PYTHONLIBS_VERSION_STRING}")
 
-    #ValidatePythonInstallation()
+#    ValidatePythonInstallation()
 
     message(STATUS "--> PYTHON_LIBRARIES: ${PYTHON_LIBRARIES}, PYTHON_INCLUDE_DIRS:${PYTHON_INCLUDE_DIRS} PYTHONLIBS_VERSION_STRING:${PYTHONLIBS_VERSION_STRING}")
 
@@ -88,10 +73,8 @@ if(BORNAGAIN_PYTHON OR BORNAGAIN_GUI)
     endif()
 
     find_package(Numpy REQUIRED)
-
 endif()
 
-
 # --- SWIG ---
 if(BORNAGAIN_PYTHON AND BORNAGAIN_GENERATE_BINDINGS)
   find_package(SWIG 3.0 REQUIRED)