soc-2008-mxcurioni: now supports current scene drawing (instead of fixed scene object...
authorMaxime Curioni <maxime.curioni@gmail.com>
Sun, 8 Jun 2008 19:35:20 +0000 (19:35 +0000)
committerMaxime Curioni <maxime.curioni@gmail.com>
Sun, 8 Jun 2008 19:35:20 +0000 (19:35 +0000)
16 files changed:
config/darwin-config.py
config/linux2-config.py
config/linuxcross-config.py
config/openbsd3-config.py
config/sunos5-config.py
config/win32-mingw-config.py
config/win32-vc-config.py
source/blender/freestyle/SConscript
source/blender/freestyle/intern/app_blender/api.cpp
source/blender/freestyle/intern/app_blender/test_config.h
source/blender/freestyle/intern/swig/ModuleWrapper.cpp
source/blender/freestyle/intern/swig/ModuleWrapper.h
source/blender/freestyle/python/3ds_export.py [new file with mode: 0644]
source/blender/freestyle/python/Freestyle.py
tools/Blender.py
tools/btools.py

index 115123f998442b1863f3c426b51b36aae72349ba..4c3b5d19e36bb66a45a6a813059d81b261fe6d0a 100644 (file)
@@ -167,7 +167,6 @@ BF_SWIG = '${BF_FREESTYLE}/swig'
 BF_SWIG_LIB = 'extern_swig'
 BF_LIB3DS = '${BF_FREESTYLE}/lib3ds'
 BF_LIB3DS_LIB = 'extern_lib3ds'
-BF_LIB3DS_LIBPATH = '${BF_LIB3DS}/lib3ds/.libs'
 BF_LIB3DS_INC = '${BF_LIB3DS}'
 
 # WITH_BF_OPENEXR = 'true'
index f59dcf266ee3f986958d23aeed066dd27c530edb..965b5935886d5ca56f128e5914daa20f2b7799ba 100644 (file)
@@ -93,7 +93,6 @@ BF_SWIG = '${BF_FREESTYLE}/swig'
 BF_SWIG_LIB = 'extern_swig'
 BF_LIB3DS = '${BF_FREESTYLE}/lib3ds'
 BF_LIB3DS_LIB = 'extern_lib3ds'
-BF_LIB3DS_LIBPATH = '${BF_LIB3DS}/lib3ds/.libs'
 BF_LIB3DS_INC = '${BF_LIB3DS}'
 
 #WITH_BF_NSPR = 'true'
index 603f6a1a8802e158252f79f58f80c4e2db75e699..c695e0e04e3755c5cde2ae105671aa9d77cafb27 100644 (file)
@@ -13,7 +13,6 @@ BF_SWIG = '${BF_FREESTYLE}/swig'
 BF_SWIG_LIB = 'extern_swig'
 BF_LIB3DS = '${BF_FREESTYLE}/lib3ds'
 BF_LIB3DS_LIB = 'extern_lib3ds'
-BF_LIB3DS_LIBPATH = '${BF_LIB3DS}/lib3ds/.libs'
 BF_LIB3DS_INC = '${BF_LIB3DS}'
 
 ###########################
index 9a4c0d6f34e8ce378e92ee891ba058b30dd4f948..6b8d30f8bca4902fe575d6449f5dfd61cf2f7909 100644 (file)
@@ -87,7 +87,6 @@ BF_SWIG = '${BF_FREESTYLE}/swig'
 BF_SWIG_LIB = 'extern_swig'
 BF_LIB3DS = '${BF_FREESTYLE}/lib3ds'
 BF_LIB3DS_LIB = 'extern_lib3ds'
-BF_LIB3DS_LIBPATH = '${BF_LIB3DS}/lib3ds/.libs'
 BF_LIB3DS_INC = '${BF_LIB3DS}'
 
 #WITH_BF_NSPR = 'true'
index cccc380f60cf293d6d0b1923b5fbe136ff028ba4..36ed610da3fec0876d33fc786cf0c38b62e3d38b 100644 (file)
@@ -89,7 +89,6 @@ BF_SWIG = '${BF_FREESTYLE}/swig'
 BF_SWIG_LIB = 'extern_swig'
 BF_LIB3DS = '${BF_FREESTYLE}/lib3ds'
 BF_LIB3DS_LIB = 'extern_lib3ds'
-BF_LIB3DS_LIBPATH = '${BF_LIB3DS}/lib3ds/.libs'
 BF_LIB3DS_INC = '${BF_LIB3DS}'
 
 #WITH_BF_NSPR = 'true'
index 9757c0264b5597b067de6aca24a2fb606e204362..a0e85a075485ae200fe33fb7198af645ed00761c 100644 (file)
@@ -104,7 +104,6 @@ BF_SWIG = '${BF_FREESTYLE}/swig'
 BF_SWIG_LIB = 'extern_swig'
 BF_LIB3DS = '${BF_FREESTYLE}/lib3ds'
 BF_LIB3DS_LIB = 'extern_lib3ds'
-BF_LIB3DS_LIBPATH = '${BF_LIB3DS}/lib3ds/.libs'
 BF_LIB3DS_INC = '${BF_LIB3DS}'
 
 #WITH_BF_NSPR = 'true'
index 8e7d6c56c13928460ac418140159cd8286001a62..8eace13c807aa9cee1c4e1943d411c8e9364268f 100644 (file)
@@ -115,7 +115,6 @@ BF_SWIG = '${BF_FREESTYLE}/swig'
 BF_SWIG_LIB = 'extern_swig'
 BF_LIB3DS = '${BF_FREESTYLE}/lib3ds'
 BF_LIB3DS_LIB = 'extern_lib3ds'
-BF_LIB3DS_LIBPATH = '${BF_LIB3DS}/lib3ds/.libs'
 BF_LIB3DS_INC = '${BF_LIB3DS}'
 
 #WITH_BF_NSPR = 'true'
index c9a77919f4f001bd3bf0d421cf37692220d946c9..656cecb4e750f18e29da0acca693fffa580789ec 100644 (file)
@@ -74,13 +74,21 @@ env.BlenderLib (libname="bf_freestyle",
 ########################################################
 #      swig
 #
-#      1] Run the following two commands in the source/blender/freestyle/intern/swig directory.
+#      1] Run the following three commands in the source/blender/freestyle/intern/swig directory.
 #
 #      2] Replace /Users/mx/Documents/work/GSoC_2008/bf-blender/branches/build/darwin/lib to the path
 #      of your library directory (used to locate libbf_freestyle.a)
 #
 #   3] Replace the python directories to suit your config
 
+# export SWIG_LIB=/Users/mx/Documents/work/GSoC_2008/bf-blender/branches/soc-2008-mxcurioni/extern/freestyle/swig/Lib
+
+# cd /Users/mx/Documents/work/GSoC_2008/bf-blender/branches/soc-2008-mxcurioni/source/blender/freestyle/intern/swig
+
+# /Users/mx/Documents/work/GSoC_2008/bf-blender/branches/build/darwin/bin/swig -c++ -python -o ModuleWrapper.cpp Freestyle.i
+
+# mv ./Freestyle.py ../../python/
+
 # g++ -w  -I../geometry -I../image -I../scene_graph -I../stroke -I../system -I../view_map -I../winged_edge -I/usr/include/python2.5 -I../../../blenlib -I../../../blenkernel -I../../../imbuf -I../../../makesdna -c ModuleWrapper.cpp -o ModuleWrapper.o
 
 ###########  Mac OS X ###########
index a021e30a6e5a17d7d9963e0befb76182d9410c06..c097b64ef53db7976bd60dcdbbd45f152aba44d7 100644 (file)
@@ -11,10 +11,11 @@ extern "C" {
 #endif
 
 #include "render_types.h"
-//#include "renderdatabase.h"
-/* display_draw() needs render layer info */
 #include "renderpipeline.h"
 
+#include "BLI_blenlib.h"
+#include "BPY_extern.h"
+
 #ifdef __cplusplus
 }
 #endif
@@ -25,26 +26,50 @@ using namespace std;
 extern "C" {
 #endif
 
-       void FRS_execute(Render* re) {
-               cout << "Freestyle start" << endl;
-       
+       static Controller *controller = NULL;
+       static AppGLWidget *view = NULL;
+
+       void FRS_initialize(){
                Config::Path pathconfig;
-               Controller *c = new Controller;
-               AppGLWidget *view = new AppGLWidget;
                
-               c->SetView(view);
+               if( controller == NULL )
+                       controller = new Controller;
+               
+               if( view == NULL )
+                       view = new AppGLWidget;
+       }
+
+       void FRS_execute(Render* re) {
+                       
+               FRS_initialize();
+               
+               controller->SetView(view);
                unsigned int width = re->winx;
                unsigned int height = re->winy;
                view->setWidth(width);
                view->setHeight(height);
+               view->_camera->setScreenWidthAndHeight(width, height);
+               //view->setCameraState(const float* position, const float* orientation) 
                
-               c->Load3DSFile( TEST_3DS_FILE );
+               BPY_run_python_script( TEST_3DS_EXPORT );
                
-               c->InsertStyleModule( 0, TEST_STYLE_MODULE_FILE );
-               c->toggleLayer(0, true);
-               c->ComputeViewMap();
+               char btempdir[255];
+               BLI_where_is_temp(btempdir,1);
+               string exported_3ds_file =  btempdir;
+               exported_3ds_file += "/tmp_scene_freestyle.3ds";
+               if( BLI_exists( const_cast<char *>(exported_3ds_file.c_str()) ) ) {
+                       controller->Load3DSFile( exported_3ds_file.c_str() );
+               }
+               else {
+                       cout << "Cannot find" << exported_3ds_file << endl;
+                       return;
+               }
                
-               c->DrawStrokes(); // build strokes
+               controller->InsertStyleModule( 0, TEST_STYLE_MODULE_FILE );
+               controller->toggleLayer(0, true);
+               controller->ComputeViewMap();
+               
+               controller->DrawStrokes(); // build strokes
                view->draw(); // render final result
                
                RenderResult rres;
@@ -52,8 +77,6 @@ extern "C" {
                view->readPixels(0,0,width,height,AppGLWidget::RGBA, rres.rectf );              
                re->result->renlay = render_get_active_layer(re, re->result);
                re->display_draw(re->result, NULL);
-               
-               cout << "Freestyle end" << endl;
 
        }
        
index 6507050a4e43ef57ac413af766b9f8249803b386..c2337c0ba4c68ba8b2dbb376e2c975484ae31d49 100644 (file)
@@ -1,8 +1,10 @@
-
-#define TEST_3DS_FILE "/Users/mx/Documents/work/GSoC_2008/bf-blender/branches/soc-2008-mxcurioni/source/blender/freestyle/data/models/teapot.3DS"
-
 #define TEST_STYLE_MODULE_FILE "/Users/mx/Documents/work/GSoC_2008/bf-blender/branches/soc-2008-mxcurioni/source/blender/freestyle/style_modules/contour.py"
 
 #define TEST_ROOT_DIR "/Users/mx/Documents/work/GSoC_2008/bf-blender/branches/soc-2008-mxcurioni/source/blender/freestyle"
 
 #define TEST_TEXTURE_FILE "/Users/mx/Documents/work/GSoC_2008/bf-blender/branches/soc-2008-mxcurioni/source/blender/freestyle/data/textures/papers/whitepaper.jpg"
+
+
+
+
+#define TEST_3DS_EXPORT "/Users/mx/Documents/work/GSoC_2008/bf-blender/branches/soc-2008-mxcurioni/source/blender/freestyle/python/3ds_export.py"
index 36bd39b2b15279b1b3f1ca8b2cd39b69a3e7a9f7..94662595bd9c91f400a3f400be8c382036541b53 100755 (executable)
@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.31
+ * Version 1.3.35
  * 
  * 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
@@ -13,7 +13,7 @@
 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
 
 #ifdef __cplusplus
-template<class T> class SwigValueWrapper {
+template<typename T> class SwigValueWrapper {
     T *tt;
 public:
     SwigValueWrapper() : tt(0) { }
@@ -26,6 +26,10 @@ public:
 private:
     SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
 };
+
+template <typename T> T SwigValueInit() {
+  return T();
+}
 #endif
 
 /* -----------------------------------------------------------------------------
@@ -35,14 +39,14 @@ private:
 
 /* template workaround for compilers that cannot correctly implement the C++ standard */
 #ifndef SWIGTEMPLATEDISAMBIGUATOR
-# if defined(__SUNPRO_CC)
-#   if (__SUNPRO_CC <= 0x560)
-#     define SWIGTEMPLATEDISAMBIGUATOR template
-#   else
-#     define SWIGTEMPLATEDISAMBIGUATOR 
-#   endif
+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
+#  define SWIGTEMPLATEDISAMBIGUATOR template
+# elif defined(__HP_aCC)
+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
+#  define SWIGTEMPLATEDISAMBIGUATOR template
 # else
-#   define SWIGTEMPLATEDISAMBIGUATOR 
+#  define SWIGTEMPLATEDISAMBIGUATOR
 # endif
 #endif
 
@@ -125,6 +129,12 @@ private:
 # define _CRT_SECURE_NO_DEPRECATE
 #endif
 
+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
+# define _SCL_SECURE_NO_DEPRECATE
+#endif
+
+
 
 /* Python.h has to appear first */
 #include <Python.h>
@@ -138,7 +148,7 @@ private:
 
 /* This should only be incremented when either the layout of swig_type_info changes,
    or for whatever reason, the runtime changes incompatibly */
-#define SWIG_RUNTIME_VERSION "3"
+#define SWIG_RUNTIME_VERSION "4"
 
 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 #ifdef SWIG_TYPE_TABLE
@@ -173,6 +183,7 @@ private:
 
 /* Flags for pointer conversions */
 #define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
 
 /* Flags for new pointer objects */
 #define SWIG_POINTER_OWN           0x1
@@ -313,10 +324,10 @@ SWIGINTERNINLINE int SWIG_CheckState(int r) {
 extern "C" {
 #endif
 
-typedef void *(*swig_converter_func)(void *);
+typedef void *(*swig_converter_func)(void *, int *);
 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 
-/* Structure to store inforomation on one type */
+/* Structure to store information on one type */
 typedef struct swig_type_info {
   const char             *name;                        /* mangled name of this type */
   const char             *str;                 /* human readable name of this type */
@@ -361,7 +372,7 @@ SWIG_TypeNameComp(const char *f1, const char *l1,
     while ((*f2 == ' ') && (f2 != l2)) ++f2;
     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
   }
-  return (l1 - f1) - (l2 - f2);
+  return (int)((l1 - f1) - (l2 - f2));
 }
 
 /*
@@ -443,8 +454,8 @@ SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
   Cast a pointer up an inheritance hierarchy
 */
 SWIGRUNTIMEINLINE void *
-SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
-  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
 }
 
 /* 
@@ -868,7 +879,7 @@ SWIG_Python_AddErrorMsg(const char* mesg)
     Py_DECREF(old_str);
     Py_DECREF(value);
   } else {
-    PyErr_Format(PyExc_RuntimeError, mesg);
+    PyErr_SetString(PyExc_RuntimeError, mesg);
   }
 }
 
@@ -1108,14 +1119,14 @@ SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
 /* Unpack the argument tuple */
 
 SWIGINTERN int
-SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
+SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
 {
   if (!args) {
     if (!min && !max) {
       return 1;
     } else {
       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
-                  name, (min == max ? "" : "at least "), min);
+                  name, (min == max ? "" : "at least "), (int)min);
       return 0;
     }
   }  
@@ -1123,14 +1134,14 @@ SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyOb
     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
     return 0;
   } else {
-    register int l = PyTuple_GET_SIZE(args);
+    register Py_ssize_t l = PyTuple_GET_SIZE(args);
     if (l < min) {
       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
-                  name, (min == max ? "" : "at least "), min, l);
+                  name, (min == max ? "" : "at least "), (int)min, (int)l);
       return 0;
     } else if (l > max) {
       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
-                  name, (min == max ? "" : "at most "), max, l);
+                  name, (min == max ? "" : "at most "), (int)max, (int)l);
       return 0;
     } else {
       register int i;
@@ -1428,7 +1439,7 @@ PySwigObject_dealloc(PyObject *v)
 {
   PySwigObject *sobj = (PySwigObject *) v;
   PyObject *next = sobj->next;
-  if (sobj->own) {
+  if (sobj->own == SWIG_POINTER_OWN) {
     swig_type_info *ty = sobj->ty;
     PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
     PyObject *destroy = data ? data->destroy : 0;
@@ -1446,12 +1457,13 @@ PySwigObject_dealloc(PyObject *v)
        res = ((*meth)(mself, v));
       }
       Py_XDECREF(res);
-    } else {
-      const char *name = SWIG_TypePrettyName(ty);
+    } 
 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
-      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
-#endif
+    else {
+      const char *name = SWIG_TypePrettyName(ty);
+      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
     }
+#endif
   } 
   Py_XDECREF(next);
   PyObject_DEL(v);
@@ -1609,9 +1621,11 @@ _PySwigObject_type(void) {
     (unaryfunc)0,                 /*nb_float*/
     (unaryfunc)PySwigObject_oct,  /*nb_oct*/
     (unaryfunc)PySwigObject_hex,  /*nb_hex*/
-#if PY_VERSION_HEX >= 0x02020000
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ 
-#elif PY_VERSION_HEX >= 0x02000000
+#if 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 */
+#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
+#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
 #endif
   };
@@ -1954,7 +1968,7 @@ SWIG_Python_GetSwigThis(PyObject *pyobj)
 
 SWIGRUNTIME int
 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
-  if (own) {
+  if (own == SWIG_POINTER_OWN) {
     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
     if (sobj) {
       int oldown = sobj->own;
@@ -1975,6 +1989,8 @@ SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int
     return SWIG_OK;
   } else {
     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
+    if (own)
+      *own = 0;
     while (sobj) {
       void *vptr = sobj->ptr;
       if (ty) {
@@ -1988,7 +2004,15 @@ SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int
          if (!tc) {
            sobj = (PySwigObject *)sobj->next;
          } else {
-           if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
+           if (ptr) {
+              int newmemory = 0;
+              *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
+              if (newmemory == SWIG_CAST_NEW_MEMORY) {
+                assert(own);
+                if (own)
+                  *own = *own | SWIG_CAST_NEW_MEMORY;
+              }
+            }
            break;
          }
        }
@@ -1998,7 +2022,8 @@ SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int
       }
     }
     if (sobj) {
-      if (own) *own = sobj->own;
+      if (own)
+        *own = *own | sobj->own;
       if (flags & SWIG_POINTER_DISOWN) {
        sobj->own = 0;
       }
@@ -2063,8 +2088,13 @@ SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
     }
     if (ty) {
       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
-      if (!tc) return SWIG_ERROR;
-      *ptr = SWIG_TypeCast(tc,vptr);
+      if (tc) {
+        int newmemory = 0;
+        *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
+        assert(!newmemory); /* newmemory handling not yet implemented */
+      } else {
+        return SWIG_ERROR;
+      }
     } else {
       *ptr = vptr;
     }
@@ -2680,6 +2710,7 @@ namespace Swig {
         swig_msg += msg;
       }
       if (!PyErr_Occurred()) {
+        swig_msg.insert(0, ": ");
         PyErr_SetString(error, getMessage());
       } else {
         SWIG_Python_AddErrorMsg(getMessage());
@@ -2774,7 +2805,7 @@ namespace Swig {
   class DirectorMethodException : public Swig::DirectorException {
   public:
     DirectorMethodException(const char* msg = "") 
-      : DirectorException(PyExc_RuntimeError, "Swig director method error", msg)
+      : DirectorException(PyExc_RuntimeError, "Swig director method error.", msg)
     {
     }    
 
@@ -2807,33 +2838,21 @@ namespace Swig {
 # endif
 #endif
 
-/* simple thread abstraction for pthreads on win32 */
 #ifdef __THREAD__
-# define __PTHREAD__
-# if defined(_WIN32) || defined(__WIN32__)
-#  define pthread_mutex_lock EnterCriticalSection
-#  define pthread_mutex_unlock LeaveCriticalSection
-#  define pthread_mutex_t CRITICAL_SECTION
-#  define SWIG_MUTEX_INIT(var) var
-# else
-#  include <pthread.h>
-#  define SWIG_MUTEX_INIT(var) var = PTHREAD_MUTEX_INITIALIZER 
-# endif
-#endif
-
-#ifdef  __PTHREAD__
-  struct Guard
+# include "pythread.h"
+  class Guard
   {
-    pthread_mutex_t *_mutex;
+    PyThread_type_lock & mutex_;
     
-    Guard(pthread_mutex_t &mutex) : _mutex(&mutex)
+  public:
+    Guard(PyThread_type_lock & mutex) : mutex_(mutex)
     {
-      pthread_mutex_lock(_mutex);
+      PyThread_acquire_lock(mutex_, WAIT_LOCK);
     }
     
     ~Guard()
     {
-      pthread_mutex_unlock(_mutex);
+      PyThread_release_lock(mutex_);
     }
   };
 # define SWIG_GUARD(mutex) Guard _guard(mutex)
@@ -2904,8 +2923,8 @@ namespace Swig {
   private:
     typedef std::map<void*, GCItem_var> ownership_map;
     mutable ownership_map owner;
-#ifdef __PTHREAD__
-    static pthread_mutex_t swig_mutex_own;
+#ifdef __THREAD__
+    static PyThread_type_lock swig_mutex_own;
 #endif
 
   public:
@@ -2950,8 +2969,8 @@ namespace Swig {
     }
   };
 
-#ifdef __PTHREAD__
-  pthread_mutex_t SWIG_MUTEX_INIT(Director::swig_mutex_own);
+#ifdef __THREAD__
+  PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock();
 #endif
 }
 
@@ -2963,7 +2982,7 @@ namespace Swig {
 /* -------- TYPES TABLE (BEGIN) -------- */
 
 #define SWIGTYPE_p_AdjacencyIterator swig_types[0]
-#define SWIGTYPE_p_BBoxTVecMat__Vec3Tdouble_t_t swig_types[1]
+#define SWIGTYPE_p_BBoxT_VecMat__Vec3T_double_t_t swig_types[1]
 #define SWIGTYPE_p_BinaryPredicate0D swig_types[2]
 #define SWIGTYPE_p_BinaryPredicate1D swig_types[3]
 #define SWIGTYPE_p_CalligraphicShader swig_types[4]
@@ -3114,56 +3133,56 @@ namespace Swig {
 #define SWIGTYPE_p_StrokesContainer swig_types[149]
 #define SWIGTYPE_p_StyleModule swig_types[150]
 #define SWIGTYPE_p_TVertex swig_types[151]
-#define SWIGTYPE_p_UnaryFunction0DTId_t swig_types[152]
-#define SWIGTYPE_p_UnaryFunction0DTVecMat__Vec2Tfloat_t_t swig_types[153]
-#define SWIGTYPE_p_UnaryFunction0DTVecMat__Vec3Tfloat_t_t swig_types[154]
-#define SWIGTYPE_p_UnaryFunction0DTViewShape_p_t swig_types[155]
-#define SWIGTYPE_p_UnaryFunction0DTdouble_t swig_types[156]
-#define SWIGTYPE_p_UnaryFunction0DTfloat_t swig_types[157]
-#define SWIGTYPE_p_UnaryFunction0DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t swig_types[158]
-#define SWIGTYPE_p_UnaryFunction0DTunsigned_int_t swig_types[159]
-#define SWIGTYPE_p_UnaryFunction0DTvoid_t swig_types[160]
-#define SWIGTYPE_p_UnaryFunction1DTVecMat__Vec2Tfloat_t_t swig_types[161]
-#define SWIGTYPE_p_UnaryFunction1DTVecMat__Vec3Tfloat_t_t swig_types[162]
-#define SWIGTYPE_p_UnaryFunction1DTdouble_t swig_types[163]
-#define SWIGTYPE_p_UnaryFunction1DTfloat_t swig_types[164]
-#define SWIGTYPE_p_UnaryFunction1DTstd__vectorTViewShape_p_std__allocatorTViewShape_p_t_t_t swig_types[165]
-#define SWIGTYPE_p_UnaryFunction1DTunsigned_int_t swig_types[166]
-#define SWIGTYPE_p_UnaryFunction1DTvoid_t swig_types[167]
+#define SWIGTYPE_p_UnaryFunction0DT_Id_t swig_types[152]
+#define SWIGTYPE_p_UnaryFunction0DT_VecMat__Vec2T_float_t_t swig_types[153]
+#define SWIGTYPE_p_UnaryFunction0DT_VecMat__Vec3T_float_t_t swig_types[154]
+#define SWIGTYPE_p_UnaryFunction0DT_ViewShape_p_t swig_types[155]
+#define SWIGTYPE_p_UnaryFunction0DT_double_t swig_types[156]
+#define SWIGTYPE_p_UnaryFunction0DT_float_t swig_types[157]
+#define SWIGTYPE_p_UnaryFunction0DT_std__vectorT_ViewShape_p_std__allocatorT_ViewShape_p_t_t_t swig_types[158]
+#define SWIGTYPE_p_UnaryFunction0DT_unsigned_int_t swig_types[159]
+#define SWIGTYPE_p_UnaryFunction0DT_void_t swig_types[160]
+#define SWIGTYPE_p_UnaryFunction1DT_VecMat__Vec2T_float_t_t swig_types[161]
+#define SWIGTYPE_p_UnaryFunction1DT_VecMat__Vec3T_float_t_t swig_types[162]
+#define SWIGTYPE_p_UnaryFunction1DT_double_t swig_types[163]
+#define SWIGTYPE_p_UnaryFunction1DT_float_t swig_types[164]
+#define SWIGTYPE_p_UnaryFunction1DT_std__vectorT_ViewShape_p_std__allocatorT_ViewShape_p_t_t_t swig_types[165]
+#define SWIGTYPE_p_UnaryFunction1DT_unsigned_int_t swig_types[166]
+#define SWIGTYPE_p_UnaryFunction1DT_void_t swig_types[167]
 #define SWIGTYPE_p_UnaryPredicate0D swig_types[168]
 #define SWIGTYPE_p_UnaryPredicate1D swig_types[169]
-#define SWIGTYPE_p_VecMat__HVec3Tdouble_t swig_types[170]
-#define SWIGTYPE_p_VecMat__HVec3Tfloat_t swig_types[171]
-#define SWIGTYPE_p_VecMat__HVec3Tint_t swig_types[172]
-#define SWIGTYPE_p_VecMat__HVec3Tunsigned_int_t swig_types[173]
-#define SWIGTYPE_p_VecMat__SquareMatrixTdouble_2_t swig_types[174]
-#define SWIGTYPE_p_VecMat__SquareMatrixTdouble_3_t swig_types[175]
-#define SWIGTYPE_p_VecMat__SquareMatrixTdouble_4_t swig_types[176]
-#define SWIGTYPE_p_VecMat__SquareMatrixTfloat_2_t swig_types[177]
-#define SWIGTYPE_p_VecMat__SquareMatrixTfloat_3_t swig_types[178]
-#define SWIGTYPE_p_VecMat__SquareMatrixTfloat_4_t swig_types[179]
-#define SWIGTYPE_p_VecMat__SquareMatrixTint_2_t swig_types[180]
-#define SWIGTYPE_p_VecMat__SquareMatrixTint_3_t swig_types[181]
-#define SWIGTYPE_p_VecMat__SquareMatrixTint_4_t swig_types[182]
-#define SWIGTYPE_p_VecMat__SquareMatrixTunsigned_int_2_t swig_types[183]
-#define SWIGTYPE_p_VecMat__SquareMatrixTunsigned_int_3_t swig_types[184]
-#define SWIGTYPE_p_VecMat__SquareMatrixTunsigned_int_4_t swig_types[185]
-#define SWIGTYPE_p_VecMat__Vec2Tdouble_t swig_types[186]
-#define SWIGTYPE_p_VecMat__Vec2Tfloat_t swig_types[187]
-#define SWIGTYPE_p_VecMat__Vec2Tint_t swig_types[188]
-#define SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t swig_types[189]
-#define SWIGTYPE_p_VecMat__Vec3Tdouble_t swig_types[190]
-#define SWIGTYPE_p_VecMat__Vec3Tfloat_t swig_types[191]
-#define SWIGTYPE_p_VecMat__Vec3Tint_t swig_types[192]
-#define SWIGTYPE_p_VecMat__Vec3Tunsigned_int_t swig_types[193]
-#define SWIGTYPE_p_VecMat__VecTdouble_2_t swig_types[194]
-#define SWIGTYPE_p_VecMat__VecTdouble_3_t swig_types[195]
-#define SWIGTYPE_p_VecMat__VecTfloat_2_t swig_types[196]
-#define SWIGTYPE_p_VecMat__VecTfloat_3_t swig_types[197]
-#define SWIGTYPE_p_VecMat__VecTint_2_t swig_types[198]
-#define SWIGTYPE_p_VecMat__VecTint_3_t swig_types[199]
-#define SWIGTYPE_p_VecMat__VecTunsigned_int_2_t swig_types[200]
-#define SWIGTYPE_p_VecMat__VecTunsigned_int_3_t swig_types[201]
+#define SWIGTYPE_p_VecMat__HVec3T_double_t swig_types[170]
+#define SWIGTYPE_p_VecMat__HVec3T_float_t swig_types[171]
+#define SWIGTYPE_p_VecMat__HVec3T_int_t swig_types[172]
+#define SWIGTYPE_p_VecMat__HVec3T_unsigned_int_t swig_types[173]
+#define SWIGTYPE_p_VecMat__SquareMatrixT_double_2_t swig_types[174]
+#define SWIGTYPE_p_VecMat__SquareMatrixT_double_3_t swig_types[175]
+#define SWIGTYPE_p_VecMat__SquareMatrixT_double_4_t swig_types[176]
+#define SWIGTYPE_p_VecMat__SquareMatrixT_float_2_t swig_types[177]
+#define SWIGTYPE_p_VecMat__SquareMatrixT_float_3_t swig_types[178]
+#define SWIGTYPE_p_VecMat__SquareMatrixT_float_4_t swig_types[179]
+#define SWIGTYPE_p_VecMat__SquareMatrixT_int_2_t swig_types[180]
+#define SWIGTYPE_p_VecMat__SquareMatrixT_int_3_t swig_types[181]
+#define SWIGTYPE_p_VecMat__SquareMatrixT_int_4_t swig_types[182]
+#define SWIGTYPE_p_VecMat__SquareMatrixT_unsigned_int_2_t swig_types[183]
+#define SWIGTYPE_p_VecMat__SquareMatrixT_unsigned_int_3_t swig_types[184]
+#define SWIGTYPE_p_VecMat__SquareMatrixT_unsigned_int_4_t swig_types[185]
+#define SWIGTYPE_p_VecMat__Vec2T_double_t swig_types[186]
+#define SWIGTYPE_p_VecMat__Vec2T_float_t swig_types[187]
+#define SWIGTYPE_p_VecMat__Vec2T_int_t swig_types[188]
+#define SWIGTYPE_p_VecMat__Vec2T_unsigned_int_t swig_types[189]
+#define SWIGTYPE_p_VecMat__Vec3T_double_t swig_types[190]
+#define SWIGTYPE_p_VecMat__Vec3T_float_t swig_types[191]
+#define SWIGTYPE_p_VecMat__Vec3T_int_t swig_types[192]
+#define SWIGTYPE_p_VecMat__Vec3T_unsigned_int_t swig_types[193]
+#define SWIGTYPE_p_VecMat__VecT_double_2_t swig_types[194]
+#define SWIGTYPE_p_VecMat__VecT_double_3_t swig_types[195]
+#define SWIGTYPE_p_VecMat__VecT_float_2_t swig_types[196]
+#define SWIGTYPE_p_VecMat__VecT_float_3_t swig_types[197]
+#define SWIGTYPE_p_VecMat__VecT_int_2_t swig_types[198]
+#define SWIGTYPE_p_VecMat__VecT_int_3_t swig_types[199]
+#define SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t swig_types[200]
+#define SWIGTYPE_p_VecMat__VecT_unsigned_int_3_t swig_types[201]
 #define SWIGTYPE_p_Vertex swig_types[202]
 #define SWIGTYPE_p_ViewEdge swig_types[203]
 #define SWIGTYPE_p_ViewEdgeInternal__SVertexIterator swig_types[204]
@@ -3171,8 +3190,8 @@ namespace Swig {
 #define SWIGTYPE_p_ViewMap swig_types[206]
 #define SWIGTYPE_p_ViewShape swig_types[207]
 #define SWIGTYPE_p_ViewVertex swig_types[208]
-#define SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_const_traits_t swig_types[209]
-#define SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseTViewVertexInternal__edge_nonconst_traits_t swig_types[210]
+#define SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseT_ViewVertexInternal__edge_const_traits_t swig_types[209]
+#define SWIGTYPE_p_ViewVertexInternal__edge_iterator_baseT_ViewVertexInternal__edge_nonconst_traits_t swig_types[210]
 #define SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator swig_types[211]
 #define SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edge_pointers_container__iterator swig_types[212]
 #define SWIGTYPE_p_ViewVertexInternal__orientedViewEdgeIterator__edges_container__iterator swig_types[213]
@@ -3192,59 +3211,61 @@ namespace Swig {
 #define SWIGTYPE_p_fedge_iterator swig_types[227]
 #define SWIGTYPE_p_fedges_container swig_types[228]
 #define SWIGTYPE_p_float swig_types[229]
-#define SWIGTYPE_p_id_type swig_types[230]
-#define SWIGTYPE_p_int swig_types[231]
-#define SWIGTYPE_p_ltstr swig_types[232]
-#define SWIGTYPE_p_mapsMap swig_types[233]
-#define SWIGTYPE_p_occluder_container__const_iterator swig_types[234]
-#define SWIGTYPE_p_p_PyObject swig_types[235]
-#define SWIGTYPE_p_point_iterator swig_types[236]
-#define SWIGTYPE_p_point_type swig_types[237]
-#define SWIGTYPE_p_reference swig_types[238]
-#define SWIGTYPE_p_setTVecMat__Vec3Tdouble_t_t swig_types[239]
-#define SWIGTYPE_p_size_type swig_types[240]
-#define SWIGTYPE_p_std__invalid_argument swig_types[241]
-#define SWIGTYPE_p_std__pairTViewEdge_p_bool_t swig_types[242]
-#define SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t swig_types[243]
-#define SWIGTYPE_p_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__allocator_type swig_types[244]
-#define SWIGTYPE_p_std__vectorTMaterial_std__allocatorTMaterial_t_t swig_types[245]
-#define SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t swig_types[246]
-#define SWIGTYPE_p_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__allocator_type swig_types[247]
-#define SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t swig_types[248]
-#define SWIGTYPE_p_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__allocator_type swig_types[249]
-#define SWIGTYPE_p_std__vectorTTVertex_p_std__allocatorTTVertex_p_t_t swig_types[250]
-#define SWIGTYPE_p_std__vectorTVecMat__Vec2Tdouble_t_std__allocatorTVecMat__Vec2Tdouble_t_t_t swig_types[251]
-#define SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t swig_types[252]
-#define SWIGTYPE_p_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__allocator_type swig_types[253]
-#define SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t swig_types[254]
-#define SWIGTYPE_p_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__allocator_type swig_types[255]
-#define SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t swig_types[256]
-#define SWIGTYPE_p_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__allocator_type swig_types[257]
-#define SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t swig_types[258]
-#define SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t__allocator_type swig_types[259]
-#define SWIGTYPE_p_std__vectorTstd__pairTViewEdge_p_bool_t_std__allocatorTstd__pairTViewEdge_p_bool_t_t_t swig_types[260]
-#define SWIGTYPE_p_std__vectorTunsigned_int_std__allocatorTunsigned_int_t_t swig_types[261]
-#define SWIGTYPE_p_svertices_container swig_types[262]
-#define SWIGTYPE_p_swig__PySwigIterator swig_types[263]
-#define SWIGTYPE_p_unsigned_int swig_types[264]
-#define SWIGTYPE_p_unsigned_short swig_types[265]
-#define SWIGTYPE_p_value_type swig_types[266]
-#define SWIGTYPE_p_vertex_container swig_types[267]
-#define SWIGTYPE_p_vertex_iterator swig_types[268]
-#define SWIGTYPE_p_vertex_type swig_types[269]
-#define SWIGTYPE_p_viewedge_container swig_types[270]
-#define SWIGTYPE_p_viewedges_container swig_types[271]
-#define SWIGTYPE_p_viewshapes_container swig_types[272]
-#define SWIGTYPE_p_viewvertices_container swig_types[273]
-#define SWIGTYPE_p_void swig_types[274]
-#define SWIGTYPE_std__vectorTFEdge_p_std__allocatorTFEdge_p_t_t__value_type swig_types[275]
-#define SWIGTYPE_std__vectorTSVertex_p_std__allocatorTSVertex_p_t_t__value_type swig_types[276]
-#define SWIGTYPE_std__vectorTStrokeShader_p_std__allocatorTStrokeShader_p_t_t__value_type swig_types[277]
-#define SWIGTYPE_std__vectorTViewEdge_p_std__allocatorTViewEdge_p_t_t__value_type swig_types[278]
-#define SWIGTYPE_std__vectorTViewShape_p_std__allocatorTViewShape_p_t_t__value_type swig_types[279]
-#define SWIGTYPE_std__vectorTViewVertex_p_std__allocatorTViewVertex_p_t_t__value_type swig_types[280]
-static swig_type_info *swig_types[282];
-static swig_module_info swig_module = {swig_types, 281, 0, 0, 0, 0};
+#define SWIGTYPE_p_id_to_index_map swig_types[230]
+#define SWIGTYPE_p_id_type swig_types[231]
+#define SWIGTYPE_p_int swig_types[232]
+#define SWIGTYPE_p_ltstr swig_types[233]
+#define SWIGTYPE_p_mapsMap swig_types[234]
+#define SWIGTYPE_p_occluder_container__const_iterator swig_types[235]
+#define SWIGTYPE_p_p_PyObject swig_types[236]
+#define SWIGTYPE_p_point_iterator swig_types[237]
+#define SWIGTYPE_p_point_type swig_types[238]
+#define SWIGTYPE_p_reference swig_types[239]
+#define SWIGTYPE_p_setT_VecMat__Vec3T_double_t_t swig_types[240]
+#define SWIGTYPE_p_size_type swig_types[241]
+#define SWIGTYPE_p_std__invalid_argument swig_types[242]
+#define SWIGTYPE_p_std__mapT_int_int_std__lessT_int_t_std__allocatorT_std__pairT_int_const_int_t_t_t swig_types[243]
+#define SWIGTYPE_p_std__pairT_ViewEdge_p_bool_t swig_types[244]
+#define SWIGTYPE_p_std__vectorT_FEdge_p_std__allocatorT_FEdge_p_t_t swig_types[245]
+#define SWIGTYPE_p_std__vectorT_FEdge_p_std__allocatorT_FEdge_p_t_t__allocator_type swig_types[246]
+#define SWIGTYPE_p_std__vectorT_Material_std__allocatorT_Material_t_t swig_types[247]
+#define SWIGTYPE_p_std__vectorT_SVertex_p_std__allocatorT_SVertex_p_t_t swig_types[248]
+#define SWIGTYPE_p_std__vectorT_SVertex_p_std__allocatorT_SVertex_p_t_t__allocator_type swig_types[249]
+#define SWIGTYPE_p_std__vectorT_StrokeShader_p_std__allocatorT_StrokeShader_p_t_t swig_types[250]
+#define SWIGTYPE_p_std__vectorT_StrokeShader_p_std__allocatorT_StrokeShader_p_t_t__allocator_type swig_types[251]
+#define SWIGTYPE_p_std__vectorT_TVertex_p_std__allocatorT_TVertex_p_t_t swig_types[252]
+#define SWIGTYPE_p_std__vectorT_VecMat__Vec2T_double_t_std__allocatorT_VecMat__Vec2T_double_t_t_t swig_types[253]
+#define SWIGTYPE_p_std__vectorT_ViewEdge_p_std__allocatorT_ViewEdge_p_t_t swig_types[254]
+#define SWIGTYPE_p_std__vectorT_ViewEdge_p_std__allocatorT_ViewEdge_p_t_t__allocator_type swig_types[255]
+#define SWIGTYPE_p_std__vectorT_ViewShape_p_std__allocatorT_ViewShape_p_t_t swig_types[256]
+#define SWIGTYPE_p_std__vectorT_ViewShape_p_std__allocatorT_ViewShape_p_t_t__allocator_type swig_types[257]
+#define SWIGTYPE_p_std__vectorT_ViewVertex_p_std__allocatorT_ViewVertex_p_t_t swig_types[258]
+#define SWIGTYPE_p_std__vectorT_ViewVertex_p_std__allocatorT_ViewVertex_p_t_t__allocator_type swig_types[259]
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[260]
+#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t__allocator_type swig_types[261]
+#define SWIGTYPE_p_std__vectorT_std__pairT_ViewEdge_p_bool_t_std__allocatorT_std__pairT_ViewEdge_p_bool_t_t_t swig_types[262]
+#define SWIGTYPE_p_std__vectorT_unsigned_int_std__allocatorT_unsigned_int_t_t swig_types[263]
+#define SWIGTYPE_p_svertices_container swig_types[264]
+#define SWIGTYPE_p_swig__PySwigIterator swig_types[265]
+#define SWIGTYPE_p_unsigned_int swig_types[266]
+#define SWIGTYPE_p_unsigned_short swig_types[267]
+#define SWIGTYPE_p_value_type swig_types[268]
+#define SWIGTYPE_p_vertex_container swig_types[269]
+#define SWIGTYPE_p_vertex_iterator swig_types[270]
+#define SWIGTYPE_p_vertex_type swig_types[271]
+#define SWIGTYPE_p_viewedge_container swig_types[272]
+#define SWIGTYPE_p_viewedges_container swig_types[273]
+#define SWIGTYPE_p_viewshapes_container swig_types[274]
+#define SWIGTYPE_p_viewvertices_container swig_types[275]
+#define SWIGTYPE_p_void swig_types[276]
+#define SWIGTYPE_std__vectorT_FEdge_p_std__allocatorT_FEdge_p_t_t__value_type swig_types[277]
+#define SWIGTYPE_std__vectorT_SVertex_p_std__allocatorT_SVertex_p_t_t__value_type swig_types[278]
+#define SWIGTYPE_std__vectorT_StrokeShader_p_std__allocatorT_StrokeShader_p_t_t__value_type swig_types[279]
+#define SWIGTYPE_std__vectorT_ViewEdge_p_std__allocatorT_ViewEdge_p_t_t__value_type swig_types[280]
+#define SWIGTYPE_std__vectorT_ViewShape_p_std__allocatorT_ViewShape_p_t_t__value_type swig_types[281]
+#define SWIGTYPE_std__vectorT_ViewVertex_p_std__allocatorT_ViewVertex_p_t_t__value_type swig_types[282]
+static swig_type_info *swig_types[284];
+static swig_module_info swig_module = {swig_types, 283, 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)
 
@@ -3263,7 +3284,7 @@ static swig_module_info swig_module = {swig_types, 281, 0, 0, 0, 0};
 
 #define SWIG_name    "_Freestyle"
 
-#define SWIGVERSION 0x010331 
+#define SWIGVERSION 0x010335 
 #define SWIG_VERSION SWIGVERSION
 
 
@@ -3291,7 +3312,9 @@ namespace swig {
     
     PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
     {
-      if (initial_ref) Py_XINCREF(_obj);
+      if (initial_ref) {
+        Py_XINCREF(_obj);
+      }
     }
     
     PyObject_ptr & operator=(const PyObject_ptr& item) 
@@ -3439,17 +3462,22 @@ namespace swig {
     // C++ common/needed methods
     virtual PySwigIterator *copy() const = 0;
 
-    PyObject *next()
+    PyObject *next()     
     {
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
       PyObject *obj = value();
-      incr();
-      return obj;
+      incr();       
+      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
+      return obj;     
     }
 
     PyObject *previous()
     {
+      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
       decr();
-      return value();
+      PyObject *obj = value();
+      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads       
+      return obj;
     }
 
     PySwigIterator *advance(ptrdiff_t n)
@@ -4532,12 +4560,12 @@ namespace swig
 
     ~PySequence_Cont()
     {
-      if (_seq) Py_DECREF(_seq);
+      Py_XDECREF(_seq);
     }
 
     size_type size() const
     {
-      return PySequence_Size(_seq);
+      return static_cast<size_type>(PySequence_Size(_seq));
     }
 
     bool empty() const
@@ -4600,14 +4628,12 @@ namespace swig
 
 
 #include <limits.h>
-#ifndef LLONG_MIN
-# define LLONG_MIN     LONG_LONG_MIN
-#endif
-#ifndef LLONG_MAX
-# define LLONG_MAX     LONG_LONG_MAX
-#endif
-#ifndef ULLONG_MAX
-# define ULLONG_MAX    ULONG_LONG_MAX
+#if !defined(SWIG_NO_LLONG_MAX)
+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
+#   define LLONG_MAX __LONG_LONG_MAX__
+#   define LLONG_MIN (-LLONG_MAX - 1LL)
+#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
+# endif
 #endif
 
 
@@ -4675,7 +4701,14 @@ namespace swig {
     typedef T value_type;
 
     static int asptr(PyObject *obj, sequence **seq) {
-      if (PySequence_Check(obj)) {
+      if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
+       sequence *p;
+       if (SWIG_ConvertPtr(obj,(void**)&p,
+                           swig::type_info<sequence>(),0) == SWIG_OK) {
+         if (seq) *seq = p;
+         return SWIG_OLDOBJ;
+       }
+      } else if (PySequence_Check(obj)) {
        try {
          PySequence_Cont<value_type> pyseq(obj);
          if (seq) {
@@ -4694,13 +4727,6 @@ namespace swig {
          }
          return SWIG_ERROR;
        }
-      } else {
-       sequence *p;
-       if (SWIG_ConvertPtr(obj,(void**)&p,
-                           swig::type_info<sequence>(),0) == SWIG_OK) {
-         if (seq) *seq = p;
-         return SWIG_OLDOBJ;
-       }
       }
       return SWIG_ERROR;
     }
@@ -4756,21 +4782,21 @@ 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 >" " >";
+           return "std::vector<" "int" "," "std::allocator< int >" " >";
          }
        };
       }
     
-SWIGINTERN swig::PySwigIterator *std_vector_Sl_int_Sg__iterator(std::vector<int > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
     }
-SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector<int > const *self){
+SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
       return !(self->empty());
     }
-SWIGINTERN std::vector<int >::size_type std_vector_Sl_int_Sg____len__(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();
     }
 
@@ -4788,32 +4814,32 @@ SWIG_From_size_t  (size_t value)
   return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
 }
 
-SWIGINTERN std::vector<int >::value_type std_vector_Sl_int_Sg__pop(std::vector<int > *self){
+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();
+      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){
+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);
     }
-SWIGINTERN void std_vector_Sl_int_Sg____setslice__(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__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
       swig::setslice(self, i, j, 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){
+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);
     }
-SWIGINTERN void std_vector_Sl_int_Sg____delitem__(std::vector<int > *self,std::vector<int >::difference_type i){
+SWIGINTERN void std_vector_Sl_int_Sg____delitem__(std::vector< int > *self,std::vector< int >::difference_type i){
       self->erase(swig::getpos(self,i));
     }
-SWIGINTERN std::vector<int >::value_type const &std_vector_Sl_int_Sg____getitem__(std::vector<int > const *self,std::vector<int >::difference_type i){
+SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem__(std::vector< int > const *self,std::vector< int >::difference_type i){
       return *(swig::cgetpos(self, i));
     }
-SWIGINTERN void std_vector_Sl_int_Sg____setitem__(std::vector<int > *self,std::vector<int >::difference_type i,std::vector<int >::value_type const &x){
+SWIGINTERN void std_vector_Sl_int_Sg____setitem__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector<int > *self,std::vector<int >::value_type const &x){
+SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
       self->push_back(x);
     }
 
@@ -4933,18 +4959,11 @@ SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val)
 SWIGINTERN int
 SWIG_AsVal_bool (PyObject *obj, bool *val)
 {
-  if (obj == Py_True) {
-    if (val) *val = true;
-    return SWIG_OK;
-  } else if (obj == Py_False) {
-    if (val) *val = false;
-    return SWIG_OK;
-  } else {
-    long v = 0;
-    int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
-    if (SWIG_IsOK(res) && val) *val = v ? true : false;
-    return res;
-  }
+  int r = PyObject_IsTrue(obj);
+  if (r == -1)
+    return SWIG_ERROR;
+  if (val) *val = r ? true : false;
+  return SWIG_OK;
 }
 
 
@@ -4957,49 +4976,49 @@ SWIG_AsVal_bool (PyObject *obj, bool *val)
 
 
       namespace swig {
-       template <>  struct traits<std::vector<ViewShape*, std::allocator<ViewShape * > > > {
+       template <>  struct traits<std::vector<ViewShape*, std::allocator< ViewShape * > > > {
          typedef value_category category;
          static const char* type_name() {
-           return "std::vector<" "ViewShape" " *," "std::allocator<ViewShape * >" " >";
+           return "std::vector<" "ViewShape" " *," "std::allocator< ViewShape * >" " >";
          }
        };
       }
     
-SWIGINTERN swig::PySwigIterator *std_vector_Sl_ViewShape_Sm__Sg__iterator(std::vector<ViewShape * > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_ViewShape_Sm__Sg__iterator(std::vector< ViewShape * > *self,PyObject **PYTHON_SELF){
       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
     }
-SWIGINTERN bool std_vector_Sl_ViewShape_Sm__Sg____nonzero__(std::vector<ViewShape * > const *self){
+SWIGINTERN bool std_vector_Sl_ViewShape_Sm__Sg____nonzero__(std::vector< ViewShape * > const *self){
       return !(self->empty());
     }
-SWIGINTERN std::vector<ViewShape * >::size_type std_vector_Sl_ViewShape_Sm__Sg____len__(std::vector<ViewShape * > const *self){
+SWIGINTERN std::vector< ViewShape * >::size_type std_vector_Sl_ViewShape_Sm__Sg____len__(std::vector< ViewShape * > const *self){
       return self->size();
     }
-SWIGINTERN std::vector<ViewShape * >::value_type std_vector_Sl_ViewShape_Sm__Sg__pop(std::vector<ViewShape * > *self){
+SWIGINTERN std::vector< ViewShape * >::value_type std_vector_Sl_ViewShape_Sm__Sg__pop(std::vector< ViewShape * > *self){
       if (self->size() == 0)
        throw std::out_of_range("pop from empty container");
-      std::vector<ViewShape*,std::allocator<ViewShape * > >::value_type x = self->back();
+      std::vector<ViewShape*,std::allocator< ViewShape * > >::value_type x = self->back();
       self->pop_back();
       return x;
     }
-SWIGINTERN std::vector<ViewShape *,std::allocator<ViewShape * > > *std_vector_Sl_ViewShape_Sm__Sg____getslice__(std::vector<ViewShape * > *self,std::vector<ViewShape * >::difference_type i,std::vector<ViewShape * >::difference_type j){
+SWIGINTERN std::vector< ViewShape *,std::allocator< ViewShape * > > *std_vector_Sl_ViewShape_Sm__Sg____getslice__(std::vector< ViewShape * > *self,std::vector< ViewShape * >::difference_type i,std::vector< ViewShape * >::difference_type j){
       return swig::getslice(self, i, j);
     }
-SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg____setslice__(std::vector<ViewShape * > *self,std::vector<ViewShape * >::difference_type i,std::vector<ViewShape * >::difference_type j,std::vector<ViewShape *,std::allocator<ViewShape * > > const &v){
+SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg____setslice__(std::vector< ViewShape * > *self,std::vector< ViewShape * >::difference_type i,std::vector< ViewShape * >::difference_type j,std::vector< ViewShape *,std::allocator< ViewShape * > > const &v){
       swig::setslice(self, i, j, v);
     }
-SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg____delslice__(std::vector<ViewShape * > *self,std::vector<ViewShape * >::difference_type i,std::vector<ViewShape * >::difference_type j){
+SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg____delslice__(std::vector< ViewShape * > *self,std::vector< ViewShape * >::difference_type i,std::vector< ViewShape * >::difference_type j){
       swig::delslice(self, i, j);
     }
-SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg____delitem__(std::vector<ViewShape * > *self,std::vector<ViewShape * >::difference_type i){
+SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg____delitem__(std::vector< ViewShape * > *self,std::vector< ViewShape * >::difference_type i){
       self->erase(swig::getpos(self,i));
     }
-SWIGINTERN std::vector<ViewShape * >::value_type std_vector_Sl_ViewShape_Sm__Sg____getitem__(std::vector<ViewShape * > *self,std::vector<ViewShape * >::difference_type i){
+SWIGINTERN std::vector< ViewShape * >::value_type std_vector_Sl_ViewShape_Sm__Sg____getitem__(std::vector< ViewShape * > *self,std::vector< ViewShape * >::difference_type i){
       return *(swig::cgetpos(self, i));
     }
-SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg____setitem__(std::vector<ViewShape * > *self,std::vector<ViewShape * >::difference_type i,std::vector<ViewShape * >::value_type x){
+SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg____setitem__(std::vector< ViewShape * > *self,std::vector< ViewShape * >::difference_type i,std::vector< ViewShape * >::value_type x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg__append(std::vector<ViewShape * > *self,std::vector<ViewShape * >::value_type x){
+SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg__append(std::vector< ViewShape * > *self,std::vector< ViewShape * >::value_type x){
       self->push_back(x);
     }
 
@@ -5012,49 +5031,49 @@ SWIGINTERN void std_vector_Sl_ViewShape_Sm__Sg__append(std::vector<ViewShape * >
 
 
       namespace swig {
-       template <>  struct traits<std::vector<ViewEdge*, std::allocator<ViewEdge * > > > {
+       template <>  struct traits<std::vector<ViewEdge*, std::allocator< ViewEdge * > > > {
          typedef value_category category;
          static const char* type_name() {
-           return "std::vector<" "ViewEdge" " *," "std::allocator<ViewEdge * >" " >";
+           return "std::vector<" "ViewEdge" " *," "std::allocator< ViewEdge * >" " >";
          }
        };
       }
     
-SWIGINTERN swig::PySwigIterator *std_vector_Sl_ViewEdge_Sm__Sg__iterator(std::vector<ViewEdge * > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_ViewEdge_Sm__Sg__iterator(std::vector< ViewEdge * > *self,PyObject **PYTHON_SELF){
       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
     }
-SWIGINTERN bool std_vector_Sl_ViewEdge_Sm__Sg____nonzero__(std::vector<ViewEdge * > const *self){
+SWIGINTERN bool std_vector_Sl_ViewEdge_Sm__Sg____nonzero__(std::vector< ViewEdge * > const *self){
       return !(self->empty());
     }
-SWIGINTERN std::vector<ViewEdge * >::size_type std_vector_Sl_ViewEdge_Sm__Sg____len__(std::vector<ViewEdge * > const *self){
+SWIGINTERN std::vector< ViewEdge * >::size_type std_vector_Sl_ViewEdge_Sm__Sg____len__(std::vector< ViewEdge * > const *self){
       return self->size();
     }
-SWIGINTERN std::vector<ViewEdge * >::value_type std_vector_Sl_ViewEdge_Sm__Sg__pop(std::vector<ViewEdge * > *self){
+SWIGINTERN std::vector< ViewEdge * >::value_type std_vector_Sl_ViewEdge_Sm__Sg__pop(std::vector< ViewEdge * > *self){
       if (self->size() == 0)
        throw std::out_of_range("pop from empty container");
-      std::vector<ViewEdge*,std::allocator<ViewEdge * > >::value_type x = self->back();
+      std::vector<ViewEdge*,std::allocator< ViewEdge * > >::value_type x = self->back();
       self->pop_back();
       return x;
     }
-SWIGINTERN std::vector<ViewEdge *,std::allocator<ViewEdge * > > *std_vector_Sl_ViewEdge_Sm__Sg____getslice__(std::vector<ViewEdge * > *self,std::vector<ViewEdge * >::difference_type i,std::vector<ViewEdge * >::difference_type j){
+SWIGINTERN std::vector< ViewEdge *,std::allocator< ViewEdge * > > *std_vector_Sl_ViewEdge_Sm__Sg____getslice__(std::vector< ViewEdge * > *self,std::vector< ViewEdge * >::difference_type i,std::vector< ViewEdge * >::difference_type j){
       return swig::getslice(self, i, j);
     }
-SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg____setslice__(std::vector<ViewEdge * > *self,std::vector<ViewEdge * >::difference_type i,std::vector<ViewEdge * >::difference_type j,std::vector<ViewEdge *,std::allocator<ViewEdge * > > const &v){
+SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg____setslice__(std::vector< ViewEdge * > *self,std::vector< ViewEdge * >::difference_type i,std::vector< ViewEdge * >::difference_type j,std::vector< ViewEdge *,std::allocator< ViewEdge * > > const &v){
       swig::setslice(self, i, j, v);
     }
-SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg____delslice__(std::vector<ViewEdge * > *self,std::vector<ViewEdge * >::difference_type i,std::vector<ViewEdge * >::difference_type j){
+SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg____delslice__(std::vector< ViewEdge * > *self,std::vector< ViewEdge * >::difference_type i,std::vector< ViewEdge * >::difference_type j){
       swig::delslice(self, i, j);
     }
-SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg____delitem__(std::vector<ViewEdge * > *self,std::vector<ViewEdge * >::difference_type i){
+SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg____delitem__(std::vector< ViewEdge * > *self,std::vector< ViewEdge * >::difference_type i){
       self->erase(swig::getpos(self,i));
     }
-SWIGINTERN std::vector<ViewEdge * >::value_type std_vector_Sl_ViewEdge_Sm__Sg____getitem__(std::vector<ViewEdge * > *self,std::vector<ViewEdge * >::difference_type i){
+SWIGINTERN std::vector< ViewEdge * >::value_type std_vector_Sl_ViewEdge_Sm__Sg____getitem__(std::vector< ViewEdge * > *self,std::vector< ViewEdge * >::difference_type i){
       return *(swig::cgetpos(self, i));
     }
-SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg____setitem__(std::vector<ViewEdge * > *self,std::vector<ViewEdge * >::difference_type i,std::vector<ViewEdge * >::value_type x){
+SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg____setitem__(std::vector< ViewEdge * > *self,std::vector< ViewEdge * >::difference_type i,std::vector< ViewEdge * >::value_type x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg__append(std::vector<ViewEdge * > *self,std::vector<ViewEdge * >::value_type x){
+SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg__append(std::vector< ViewEdge * > *self,std::vector< ViewEdge * >::value_type x){
       self->push_back(x);
     }
 
@@ -5067,49 +5086,49 @@ SWIGINTERN void std_vector_Sl_ViewEdge_Sm__Sg__append(std::vector<ViewEdge * > *
 
 
       namespace swig {
-       template <>  struct traits<std::vector<FEdge*, std::allocator<FEdge * > > > {
+       template <>  struct traits<std::vector<FEdge*, std::allocator< FEdge * > > > {
          typedef value_category category;
          static const char* type_name() {
-           return "std::vector<" "FEdge" " *," "std::allocator<FEdge * >" " >";
+           return "std::vector<" "FEdge" " *," "std::allocator< FEdge * >" " >";
          }
        };
       }
     
-SWIGINTERN swig::PySwigIterator *std_vector_Sl_FEdge_Sm__Sg__iterator(std::vector<FEdge * > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_FEdge_Sm__Sg__iterator(std::vector< FEdge * > *self,PyObject **PYTHON_SELF){
       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
     }
-SWIGINTERN bool std_vector_Sl_FEdge_Sm__Sg____nonzero__(std::vector<FEdge * > const *self){
+SWIGINTERN bool std_vector_Sl_FEdge_Sm__Sg____nonzero__(std::vector< FEdge * > const *self){
       return !(self->empty());
     }
-SWIGINTERN std::vector<FEdge * >::size_type std_vector_Sl_FEdge_Sm__Sg____len__(std::vector<FEdge * > const *self){
+SWIGINTERN std::vector< FEdge * >::size_type std_vector_Sl_FEdge_Sm__Sg____len__(std::vector< FEdge * > const *self){
       return self->size();
     }
-SWIGINTERN std::vector<FEdge * >::value_type std_vector_Sl_FEdge_Sm__Sg__pop(std::vector<FEdge * > *self){
+SWIGINTERN std::vector< FEdge * >::value_type std_vector_Sl_FEdge_Sm__Sg__pop(std::vector< FEdge * > *self){
       if (self->size() == 0)
        throw std::out_of_range("pop from empty container");
-      std::vector<FEdge*,std::allocator<FEdge * > >::value_type x = self->back();
+      std::vector<FEdge*,std::allocator< FEdge * > >::value_type x = self->back();
       self->pop_back();
       return x;
     }
-SWIGINTERN std::vector<FEdge *,std::allocator<FEdge * > > *std_vector_Sl_FEdge_Sm__Sg____getslice__(std::vector<FEdge * > *self,std::vector<FEdge * >::difference_type i,std::vector<FEdge * >::difference_type j){
+SWIGINTERN std::vector< FEdge *,std::allocator< FEdge * > > *std_vector_Sl_FEdge_Sm__Sg____getslice__(std::vector< FEdge * > *self,std::vector< FEdge * >::difference_type i,std::vector< FEdge * >::difference_type j){
       return swig::getslice(self, i, j);
     }
-SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg____setslice__(std::vector<FEdge * > *self,std::vector<FEdge * >::difference_type i,std::vector<FEdge * >::difference_type j,std::vector<FEdge *,std::allocator<FEdge * > > const &v){
+SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg____setslice__(std::vector< FEdge * > *self,std::vector< FEdge * >::difference_type i,std::vector< FEdge * >::difference_type j,std::vector< FEdge *,std::allocator< FEdge * > > const &v){
       swig::setslice(self, i, j, v);
     }
-SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg____delslice__(std::vector<FEdge * > *self,std::vector<FEdge * >::difference_type i,std::vector<FEdge * >::difference_type j){
+SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg____delslice__(std::vector< FEdge * > *self,std::vector< FEdge * >::difference_type i,std::vector< FEdge * >::difference_type j){
       swig::delslice(self, i, j);
     }
-SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg____delitem__(std::vector<FEdge * > *self,std::vector<FEdge * >::difference_type i){
+SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg____delitem__(std::vector< FEdge * > *self,std::vector< FEdge * >::difference_type i){
       self->erase(swig::getpos(self,i));
     }
-SWIGINTERN std::vector<FEdge * >::value_type std_vector_Sl_FEdge_Sm__Sg____getitem__(std::vector<FEdge * > *self,std::vector<FEdge * >::difference_type i){
+SWIGINTERN std::vector< FEdge * >::value_type std_vector_Sl_FEdge_Sm__Sg____getitem__(std::vector< FEdge * > *self,std::vector< FEdge * >::difference_type i){
       return *(swig::cgetpos(self, i));
     }
-SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg____setitem__(std::vector<FEdge * > *self,std::vector<FEdge * >::difference_type i,std::vector<FEdge * >::value_type x){
+SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg____setitem__(std::vector< FEdge * > *self,std::vector< FEdge * >::difference_type i,std::vector< FEdge * >::value_type x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg__append(std::vector<FEdge * > *self,std::vector<FEdge * >::value_type x){
+SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg__append(std::vector< FEdge * > *self,std::vector< FEdge * >::value_type x){
       self->push_back(x);
     }
 
@@ -5122,49 +5141,49 @@ SWIGINTERN void std_vector_Sl_FEdge_Sm__Sg__append(std::vector<FEdge * > *self,s
 
 
       namespace swig {
-       template <>  struct traits<std::vector<ViewVertex*, std::allocator<ViewVertex * > > > {
+       template <>  struct traits<std::vector<ViewVertex*, std::allocator< ViewVertex * > > > {
          typedef value_category category;
          static const char* type_name() {
-           return "std::vector<" "ViewVertex" " *," "std::allocator<ViewVertex * >" " >";
+           return "std::vector<" "ViewVertex" " *," "std::allocator< ViewVertex * >" " >";
          }
        };
       }
     
-SWIGINTERN swig::PySwigIterator *std_vector_Sl_ViewVertex_Sm__Sg__iterator(std::vector<ViewVertex * > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_ViewVertex_Sm__Sg__iterator(std::vector< ViewVertex * > *self,PyObject **PYTHON_SELF){
       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
     }
-SWIGINTERN bool std_vector_Sl_ViewVertex_Sm__Sg____nonzero__(std::vector<ViewVertex * > const *self){
+SWIGINTERN bool std_vector_Sl_ViewVertex_Sm__Sg____nonzero__(std::vector< ViewVertex * > const *self){
       return !(self->empty());
     }
-SWIGINTERN std::vector<ViewVertex * >::size_type std_vector_Sl_ViewVertex_Sm__Sg____len__(std::vector<ViewVertex * > const *self){
+SWIGINTERN std::vector< ViewVertex * >::size_type std_vector_Sl_ViewVertex_Sm__Sg____len__(std::vector< ViewVertex * > const *self){
       return self->size();
     }
-SWIGINTERN std::vector<ViewVertex * >::value_type std_vector_Sl_ViewVertex_Sm__Sg__pop(std::vector<ViewVertex * > *self){
+SWIGINTERN std::vector< ViewVertex * >::value_type std_vector_Sl_ViewVertex_Sm__Sg__pop(std::vector< ViewVertex * > *self){
       if (self->size() == 0)
        throw std::out_of_range("pop from empty container");
-      std::vector<ViewVertex*,std::allocator<ViewVertex * > >::value_type x = self->back();
+      std::vector<ViewVertex*,std::allocator< ViewVertex * > >::value_type x = self->back();
       self->pop_back();
       return x;
     }
-SWIGINTERN std::vector<ViewVertex *,std::allocator<ViewVertex * > > *std_vector_Sl_ViewVertex_Sm__Sg____getslice__(std::vector<ViewVertex * > *self,std::vector<ViewVertex * >::difference_type i,std::vector<ViewVertex * >::difference_type j){
+SWIGINTERN std::vector< ViewVertex *,std::allocator< ViewVertex * > > *std_vector_Sl_ViewVertex_Sm__Sg____getslice__(std::vector< ViewVertex * > *self,std::vector< ViewVertex * >::difference_type i,std::vector< ViewVertex * >::difference_type j){
       return swig::getslice(self, i, j);
     }
-SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg____setslice__(std::vector<ViewVertex * > *self,std::vector<ViewVertex * >::difference_type i,std::vector<ViewVertex * >::difference_type j,std::vector<ViewVertex *,std::allocator<ViewVertex * > > const &v){
+SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg____setslice__(std::vector< ViewVertex * > *self,std::vector< ViewVertex * >::difference_type i,std::vector< ViewVertex * >::difference_type j,std::vector< ViewVertex *,std::allocator< ViewVertex * > > const &v){
       swig::setslice(self, i, j, v);
     }
-SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg____delslice__(std::vector<ViewVertex * > *self,std::vector<ViewVertex * >::difference_type i,std::vector<ViewVertex * >::difference_type j){
+SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg____delslice__(std::vector< ViewVertex * > *self,std::vector< ViewVertex * >::difference_type i,std::vector< ViewVertex * >::difference_type j){
       swig::delslice(self, i, j);
     }
-SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg____delitem__(std::vector<ViewVertex * > *self,std::vector<ViewVertex * >::difference_type i){
+SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg____delitem__(std::vector< ViewVertex * > *self,std::vector< ViewVertex * >::difference_type i){
       self->erase(swig::getpos(self,i));
     }
-SWIGINTERN std::vector<ViewVertex * >::value_type std_vector_Sl_ViewVertex_Sm__Sg____getitem__(std::vector<ViewVertex * > *self,std::vector<ViewVertex * >::difference_type i){
+SWIGINTERN std::vector< ViewVertex * >::value_type std_vector_Sl_ViewVertex_Sm__Sg____getitem__(std::vector< ViewVertex * > *self,std::vector< ViewVertex * >::difference_type i){
       return *(swig::cgetpos(self, i));
     }
-SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg____setitem__(std::vector<ViewVertex * > *self,std::vector<ViewVertex * >::difference_type i,std::vector<ViewVertex * >::value_type x){
+SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg____setitem__(std::vector< ViewVertex * > *self,std::vector< ViewVertex * >::difference_type i,std::vector< ViewVertex * >::value_type x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg__append(std::vector<ViewVertex * > *self,std::vector<ViewVertex * >::value_type x){
+SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg__append(std::vector< ViewVertex * > *self,std::vector< ViewVertex * >::value_type x){
       self->push_back(x);
     }
 
@@ -5177,49 +5196,49 @@ SWIGINTERN void std_vector_Sl_ViewVertex_Sm__Sg__append(std::vector<ViewVertex *
 
 
       namespace swig {
-       template <>  struct traits<std::vector<SVertex*, std::allocator<SVertex * > > > {
+       template <>  struct traits<std::vector<SVertex*, std::allocator< SVertex * > > > {
          typedef value_category category;
          static const char* type_name() {
-           return "std::vector<" "SVertex" " *," "std::allocator<SVertex * >" " >";
+           return "std::vector<" "SVertex" " *," "std::allocator< SVertex * >" " >";
          }
        };
       }
     
-SWIGINTERN swig::PySwigIterator *std_vector_Sl_SVertex_Sm__Sg__iterator(std::vector<SVertex * > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_SVertex_Sm__Sg__iterator(std::vector< SVertex * > *self,PyObject **PYTHON_SELF){
       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
     }
-SWIGINTERN bool std_vector_Sl_SVertex_Sm__Sg____nonzero__(std::vector<SVertex * > const *self){
+SWIGINTERN bool std_vector_Sl_SVertex_Sm__Sg____nonzero__(std::vector< SVertex * > const *self){
       return !(self->empty());
     }
-SWIGINTERN std::vector<SVertex * >::size_type std_vector_Sl_SVertex_Sm__Sg____len__(std::vector<SVertex * > const *self){
+SWIGINTERN std::vector< SVertex * >::size_type std_vector_Sl_SVertex_Sm__Sg____len__(std::vector< SVertex * > const *self){
       return self->size();
     }
-SWIGINTERN std::vector<SVertex * >::value_type std_vector_Sl_SVertex_Sm__Sg__pop(std::vector<SVertex * > *self){
+SWIGINTERN std::vector< SVertex * >::value_type std_vector_Sl_SVertex_Sm__Sg__pop(std::vector< SVertex * > *self){
       if (self->size() == 0)
        throw std::out_of_range("pop from empty container");
-      std::vector<SVertex*,std::allocator<SVertex * > >::value_type x = self->back();
+      std::vector<SVertex*,std::allocator< SVertex * > >::value_type x = self->back();
       self->pop_back();
       return x;
     }
-SWIGINTERN std::vector<SVertex *,std::allocator<SVertex * > > *std_vector_Sl_SVertex_Sm__Sg____getslice__(std::vector<SVertex * > *self,std::vector<SVertex * >::difference_type i,std::vector<SVertex * >::difference_type j){
+SWIGINTERN std::vector< SVertex *,std::allocator< SVertex * > > *std_vector_Sl_SVertex_Sm__Sg____getslice__(std::vector< SVertex * > *self,std::vector< SVertex * >::difference_type i,std::vector< SVertex * >::difference_type j){
       return swig::getslice(self, i, j);
     }
-SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg____setslice__(std::vector<SVertex * > *self,std::vector<SVertex * >::difference_type i,std::vector<SVertex * >::difference_type j,std::vector<SVertex *,std::allocator<SVertex * > > const &v){
+SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg____setslice__(std::vector< SVertex * > *self,std::vector< SVertex * >::difference_type i,std::vector< SVertex * >::difference_type j,std::vector< SVertex *,std::allocator< SVertex * > > const &v){
       swig::setslice(self, i, j, v);
     }
-SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg____delslice__(std::vector<SVertex * > *self,std::vector<SVertex * >::difference_type i,std::vector<SVertex * >::difference_type j){
+SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg____delslice__(std::vector< SVertex * > *self,std::vector< SVertex * >::difference_type i,std::vector< SVertex * >::difference_type j){
       swig::delslice(self, i, j);
     }
-SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg____delitem__(std::vector<SVertex * > *self,std::vector<SVertex * >::difference_type i){
+SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg____delitem__(std::vector< SVertex * > *self,std::vector< SVertex * >::difference_type i){
       self->erase(swig::getpos(self,i));
     }
-SWIGINTERN std::vector<SVertex * >::value_type std_vector_Sl_SVertex_Sm__Sg____getitem__(std::vector<SVertex * > *self,std::vector<SVertex * >::difference_type i){
+SWIGINTERN std::vector< SVertex * >::value_type std_vector_Sl_SVertex_Sm__Sg____getitem__(std::vector< SVertex * > *self,std::vector< SVertex * >::difference_type i){
       return *(swig::cgetpos(self, i));
     }
-SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg____setitem__(std::vector<SVertex * > *self,std::vector<SVertex * >::difference_type i,std::vector<SVertex * >::value_type x){
+SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg____setitem__(std::vector< SVertex * > *self,std::vector< SVertex * >::difference_type i,std::vector< SVertex * >::value_type x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg__append(std::vector<SVertex * > *self,std::vector<SVertex * >::value_type x){
+SWIGINTERN void std_vector_Sl_SVertex_Sm__Sg__append(std::vector< SVertex * > *self,std::vector< SVertex * >::value_type x){
       self->push_back(x);
     }
 
@@ -5318,49 +5337,49 @@ SWIG_AsPtr_std_string (PyObject * obj, std::string **val)
 
 
       namespace swig {
-       template <>  struct traits<std::vector<StrokeShader*, std::allocator<StrokeShader * > > > {
+       template <>  struct traits<std::vector<StrokeShader*, std::allocator< StrokeShader * > > > {
          typedef value_category category;
          static const char* type_name() {
-           return "std::vector<" "StrokeShader" " *," "std::allocator<StrokeShader * >" " >";
+           return "std::vector<" "StrokeShader" " *," "std::allocator< StrokeShader * >" " >";
          }
        };
       }
     
-SWIGINTERN swig::PySwigIterator *std_vector_Sl_StrokeShader_Sm__Sg__iterator(std::vector<StrokeShader * > *self,PyObject **PYTHON_SELF){
+SWIGINTERN swig::PySwigIterator *std_vector_Sl_StrokeShader_Sm__Sg__iterator(std::vector< StrokeShader * > *self,PyObject **PYTHON_SELF){
       return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
     }
-SWIGINTERN bool std_vector_Sl_StrokeShader_Sm__Sg____nonzero__(std::vector<StrokeShader * > const *self){
+SWIGINTERN bool std_vector_Sl_StrokeShader_Sm__Sg____nonzero__(std::vector< StrokeShader * > const *self){
       return !(self->empty());
     }
-SWIGINTERN std::vector<StrokeShader * >::size_type std_vector_Sl_StrokeShader_Sm__Sg____len__(std::vector<StrokeShader * > const *self){
+SWIGINTERN std::vector< StrokeShader * >::size_type std_vector_Sl_StrokeShader_Sm__Sg____len__(std::vector< StrokeShader * > const *self){
       return self->size();
     }
-SWIGINTERN std::vector<StrokeShader * >::value_type std_vector_Sl_StrokeShader_Sm__Sg__pop(std::vector<StrokeShader * > *self){
+SWIGINTERN std::vector< StrokeShader * >::value_type std_vector_Sl_StrokeShader_Sm__Sg__pop(std::vector< StrokeShader * > *self){
       if (self->size() == 0)
        throw std::out_of_range("pop from empty container");
-      std::vector<StrokeShader*,std::allocator<StrokeShader * > >::value_type x = self->back();
+      std::vector<StrokeShader*,std::allocator< StrokeShader * > >::value_type x = self->back();
       self->pop_back();
       return x;
     }
-SWIGINTERN std::vector<StrokeShader *,std::allocator<StrokeShader * > > *std_vector_Sl_StrokeShader_Sm__Sg____getslice__(std::vector<StrokeShader * > *self,std::vector<StrokeShader * >::difference_type i,std::vector<StrokeShader * >::difference_type j){
+SWIGINTERN std::vector< StrokeShader *,std::allocator< StrokeShader * > > *std_vector_Sl_StrokeShader_Sm__Sg____getslice__(std::vector< StrokeShader * > *self,std::vector< StrokeShader * >::difference_type i,std::vector< StrokeShader * >::difference_type j){
       return swig::getslice(self, i, j);
     }
-SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg____setslice__(std::vector<StrokeShader * > *self,std::vector<StrokeShader * >::difference_type i,std::vector<StrokeShader * >::difference_type j,std::vector<StrokeShader *,std::allocator<StrokeShader * > > const &v){
+SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg____setslice__(std::vector< StrokeShader * > *self,std::vector< StrokeShader * >::difference_type i,std::vector< StrokeShader * >::difference_type j,std::vector< StrokeShader *,std::allocator< StrokeShader * > > const &v){
       swig::setslice(self, i, j, v);
     }
-SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg____delslice__(std::vector<StrokeShader * > *self,std::vector<StrokeShader * >::difference_type i,std::vector<StrokeShader * >::difference_type j){
+SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg____delslice__(std::vector< StrokeShader * > *self,std::vector< StrokeShader * >::difference_type i,std::vector< StrokeShader * >::difference_type j){
       swig::delslice(self, i, j);
     }
-SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg____delitem__(std::vector<StrokeShader * > *self,std::vector<StrokeShader * >::difference_type i){
+SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg____delitem__(std::vector< StrokeShader * > *self,std::vector< StrokeShader * >::difference_type i){
       self->erase(swig::getpos(self,i));
     }
-SWIGINTERN std::vector<StrokeShader * >::value_type std_vector_Sl_StrokeShader_Sm__Sg____getitem__(std::vector<StrokeShader * > *self,std::vector<StrokeShader * >::difference_type i){
+SWIGINTERN std::vector< StrokeShader * >::value_type std_vector_Sl_StrokeShader_Sm__Sg____getitem__(std::vector< StrokeShader * > *self,std::vector< StrokeShader * >::difference_type i){
       return *(swig::cgetpos(self, i));
     }
-SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg____setitem__(std::vector<StrokeShader * > *self,std::vector<StrokeShader * >::difference_type i,std::vector<StrokeShader * >::value_type x){
+SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg____setitem__(std::vector< StrokeShader * > *self,std::vector< StrokeShader * >::difference_type i,std::vector< StrokeShader * >::value_type x){
       *(swig::getpos(self,i)) = x;
     }
-SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg__append(std::vector<StrokeShader * > *self,std::vector<StrokeShader * >::value_type x){
+SWIGINTERN void std_vector_Sl_StrokeShader_Sm__Sg__append(std::vector< StrokeShader * > *self,std::vector< StrokeShader * >::value_type x){
       self->push_back(x);
     }
 
@@ -5446,7 +5465,7 @@ ViewEdge *SwigDirector_ViewEdgeViewEdgeIterator::operator *() {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
   }
   c_result = reinterpret_cast< ViewEdge * >(swig_argp);
-  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
   return (ViewEdge *) c_result;
 }
 
@@ -5479,7 +5498,7 @@ ViewEdge *SwigDirector_ViewEdgeViewEdgeIterator::operator ->() {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
   }
   c_result = reinterpret_cast< ViewEdge * >(swig_argp);
-  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
   return (ViewEdge *) c_result;
 }
 
@@ -5666,8 +5685,8 @@ bool SwigDirector_ViewEdgeViewEdgeIterator::operator !=(ViewEdgeInternal::ViewEd
 }
 
 
-SwigDirector_UnaryFunction0DVoid::SwigDirector_UnaryFunction0DVoid(PyObject *self): UnaryFunction0D<void >(), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction0D<void > *)this, this); 
+SwigDirector_UnaryFunction0DVoid::SwigDirector_UnaryFunction0DVoid(PyObject *self): UnaryFunction0D< void >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction0D< void > *)this, this); 
 }
 
 
@@ -5729,8 +5748,8 @@ void SwigDirector_UnaryFunction0DVoid::operator ()(Interface0DIterator &iter) {
 }
 
 
-SwigDirector_UnaryFunction0DUnsigned::SwigDirector_UnaryFunction0DUnsigned(PyObject *self): UnaryFunction0D<unsigned int >(), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction0D<unsigned int > *)this, this); 
+SwigDirector_UnaryFunction0DUnsigned::SwigDirector_UnaryFunction0DUnsigned(PyObject *self): UnaryFunction0D< unsigned int >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction0D< unsigned int > *)this, this); 
 }
 
 
@@ -5800,8 +5819,8 @@ unsigned int SwigDirector_UnaryFunction0DUnsigned::operator ()(Interface0DIterat
 }
 
 
-SwigDirector_UnaryFunction0DFloat::SwigDirector_UnaryFunction0DFloat(PyObject *self): UnaryFunction0D<float >(), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction0D<float > *)this, this); 
+SwigDirector_UnaryFunction0DFloat::SwigDirector_UnaryFunction0DFloat(PyObject *self): UnaryFunction0D< float >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction0D< float > *)this, this); 
 }
 
 
@@ -5871,8 +5890,8 @@ float SwigDirector_UnaryFunction0DFloat::operator ()(Interface0DIterator &iter)
 }
 
 
-SwigDirector_UnaryFunction0DDouble::SwigDirector_UnaryFunction0DDouble(PyObject *self): UnaryFunction0D<double >(), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction0D<double > *)this, this); 
+SwigDirector_UnaryFunction0DDouble::SwigDirector_UnaryFunction0DDouble(PyObject *self): UnaryFunction0D< double >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction0D< double > *)this, this); 
 }
 
 
@@ -5942,8 +5961,8 @@ double SwigDirector_UnaryFunction0DDouble::operator ()(Interface0DIterator &iter
 }
 
 
-SwigDirector_UnaryFunction0DVec2f::SwigDirector_UnaryFunction0DVec2f(PyObject *self): UnaryFunction0D<Geometry::Vec2f >(), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction0D<Geometry::Vec2f > *)this, this); 
+SwigDirector_UnaryFunction0DVec2f::SwigDirector_UnaryFunction0DVec2f(PyObject *self): UnaryFunction0D< Geometry::Vec2f >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction0D< Geometry::Vec2f > *)this, this); 
 }
 
 
@@ -5982,11 +6001,11 @@ std::string SwigDirector_UnaryFunction0DVec2f::getName() const {
 }
 
 
-VecMat::Vec2<float > SwigDirector_UnaryFunction0DVec2f::operator ()(Interface0DIterator &iter) {
+VecMat::Vec2< float > SwigDirector_UnaryFunction0DVec2f::operator ()(Interface0DIterator &iter) {
   void *swig_argp ;
   int swig_res = 0 ;
   
-  VecMat::Vec2<float > c_result;
+  VecMat::Vec2< float > c_result;
   swig::PyObject_var obj0;
   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&iter), SWIGTYPE_p_Interface0DIterator,  0 );
   if (!swig_get_self()) {
@@ -6006,18 +6025,18 @@ VecMat::Vec2<float > SwigDirector_UnaryFunction0DVec2f::operator ()(Interface0DI
       Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DVec2f.__call__'");
     }
   }
-  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0  | 0);
+  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_VecMat__Vec2T_float_t,  0  | 0);
   if (!SWIG_IsOK(swig_res)) {
-    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""VecMat::Vec2<float >""'");
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""VecMat::Vec2< float >""'");
   }
-  c_result = *(reinterpret_cast< VecMat::Vec2<float > * >(swig_argp));
-  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< VecMat::Vec2<float > * >(swig_argp);
-  return (VecMat::Vec2<float >) c_result;
+  c_result = *(reinterpret_cast< VecMat::Vec2< float > * >(swig_argp));
+  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< VecMat::Vec2< float > * >(swig_argp);
+  return (VecMat::Vec2< float >) c_result;
 }
 
 
-SwigDirector_UnaryFunction0DVec3f::SwigDirector_UnaryFunction0DVec3f(PyObject *self): UnaryFunction0D<Geometry::Vec3f >(), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction0D<Geometry::Vec3f > *)this, this); 
+SwigDirector_UnaryFunction0DVec3f::SwigDirector_UnaryFunction0DVec3f(PyObject *self): UnaryFunction0D< Geometry::Vec3f >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction0D< Geometry::Vec3f > *)this, this); 
 }
 
 
@@ -6056,11 +6075,11 @@ std::string SwigDirector_UnaryFunction0DVec3f::getName() const {
 }
 
 
-VecMat::Vec3<float > SwigDirector_UnaryFunction0DVec3f::operator ()(Interface0DIterator &iter) {
+VecMat::Vec3< float > SwigDirector_UnaryFunction0DVec3f::operator ()(Interface0DIterator &iter) {
   void *swig_argp ;
   int swig_res = 0 ;
   
-  VecMat::Vec3<float > c_result;
+  VecMat::Vec3< float > c_result;
   swig::PyObject_var obj0;
   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&iter), SWIGTYPE_p_Interface0DIterator,  0 );
   if (!swig_get_self()) {
@@ -6080,18 +6099,18 @@ VecMat::Vec3<float > SwigDirector_UnaryFunction0DVec3f::operator ()(Interface0DI
       Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction0DVec3f.__call__'");
     }
   }
-  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_VecMat__Vec3Tfloat_t,  0  | 0);
+  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_VecMat__Vec3T_float_t,  0  | 0);
   if (!SWIG_IsOK(swig_res)) {
-    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""VecMat::Vec3<float >""'");
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""VecMat::Vec3< float >""'");
   }
-  c_result = *(reinterpret_cast< VecMat::Vec3<float > * >(swig_argp));
-  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< VecMat::Vec3<float > * >(swig_argp);
-  return (VecMat::Vec3<float >) c_result;
+  c_result = *(reinterpret_cast< VecMat::Vec3< float > * >(swig_argp));
+  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< VecMat::Vec3< float > * >(swig_argp);
+  return (VecMat::Vec3< float >) c_result;
 }
 
 
-SwigDirector_UnaryFunction0DId::SwigDirector_UnaryFunction0DId(PyObject *self): UnaryFunction0D<Id >(), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction0D<Id > *)this, this); 
+SwigDirector_UnaryFunction0DId::SwigDirector_UnaryFunction0DId(PyObject *self): UnaryFunction0D< Id >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction0D< Id > *)this, this); 
 }
 
 
@@ -6164,15 +6183,15 @@ Id SwigDirector_UnaryFunction0DId::operator ()(Interface0DIterator &iter) {
 }
 
 
-SwigDirector_UnaryFunction1DVoid::SwigDirector_UnaryFunction1DVoid(PyObject *self): UnaryFunction1D<void >(), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction1D<void > *)this, this); 
+SwigDirector_UnaryFunction1DVoid::SwigDirector_UnaryFunction1DVoid(PyObject *self): UnaryFunction1D< void >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D< void > *)this, this); 
 }
 
 
 
 
-SwigDirector_UnaryFunction1DVoid::SwigDirector_UnaryFunction1DVoid(PyObject *self, IntegrationType iType): UnaryFunction1D<void >(iType), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction1D<void > *)this, this); 
+SwigDirector_UnaryFunction1DVoid::SwigDirector_UnaryFunction1DVoid(PyObject *self, IntegrationType iType): UnaryFunction1D< void >(iType), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D< void > *)this, this); 
 }
 
 
@@ -6234,15 +6253,15 @@ void SwigDirector_UnaryFunction1DVoid::operator ()(Interface1D &inter) {
 }
 
 
-SwigDirector_UnaryFunction1DUnsigned::SwigDirector_UnaryFunction1DUnsigned(PyObject *self): UnaryFunction1D<unsigned int >(), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction1D<unsigned int > *)this, this); 
+SwigDirector_UnaryFunction1DUnsigned::SwigDirector_UnaryFunction1DUnsigned(PyObject *self): UnaryFunction1D< unsigned int >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D< unsigned int > *)this, this); 
 }
 
 
 
 
-SwigDirector_UnaryFunction1DUnsigned::SwigDirector_UnaryFunction1DUnsigned(PyObject *self, IntegrationType iType): UnaryFunction1D<unsigned int >(iType), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction1D<unsigned int > *)this, this); 
+SwigDirector_UnaryFunction1DUnsigned::SwigDirector_UnaryFunction1DUnsigned(PyObject *self, IntegrationType iType): UnaryFunction1D< unsigned int >(iType), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D< unsigned int > *)this, this); 
 }
 
 
@@ -6312,15 +6331,15 @@ unsigned int SwigDirector_UnaryFunction1DUnsigned::operator ()(Interface1D &inte
 }
 
 
-SwigDirector_UnaryFunction1DFloat::SwigDirector_UnaryFunction1DFloat(PyObject *self): UnaryFunction1D<float >(), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction1D<float > *)this, this); 
+SwigDirector_UnaryFunction1DFloat::SwigDirector_UnaryFunction1DFloat(PyObject *self): UnaryFunction1D< float >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D< float > *)this, this); 
 }
 
 
 
 
-SwigDirector_UnaryFunction1DFloat::SwigDirector_UnaryFunction1DFloat(PyObject *self, IntegrationType iType): UnaryFunction1D<float >(iType), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction1D<float > *)this, this); 
+SwigDirector_UnaryFunction1DFloat::SwigDirector_UnaryFunction1DFloat(PyObject *self, IntegrationType iType): UnaryFunction1D< float >(iType), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D< float > *)this, this); 
 }
 
 
@@ -6390,15 +6409,15 @@ float SwigDirector_UnaryFunction1DFloat::operator ()(Interface1D &inter) {
 }
 
 
-SwigDirector_UnaryFunction1DDouble::SwigDirector_UnaryFunction1DDouble(PyObject *self): UnaryFunction1D<double >(), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction1D<double > *)this, this); 
+SwigDirector_UnaryFunction1DDouble::SwigDirector_UnaryFunction1DDouble(PyObject *self): UnaryFunction1D< double >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D< double > *)this, this); 
 }
 
 
 
 
-SwigDirector_UnaryFunction1DDouble::SwigDirector_UnaryFunction1DDouble(PyObject *self, IntegrationType iType): UnaryFunction1D<double >(iType), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction1D<double > *)this, this); 
+SwigDirector_UnaryFunction1DDouble::SwigDirector_UnaryFunction1DDouble(PyObject *self, IntegrationType iType): UnaryFunction1D< double >(iType), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D< double > *)this, this); 
 }
 
 
@@ -6468,15 +6487,15 @@ double SwigDirector_UnaryFunction1DDouble::operator ()(Interface1D &inter) {
 }
 
 
-SwigDirector_UnaryFunction1DVec2f::SwigDirector_UnaryFunction1DVec2f(PyObject *self): UnaryFunction1D<Geometry::Vec2f >(), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction1D<Geometry::Vec2f > *)this, this); 
+SwigDirector_UnaryFunction1DVec2f::SwigDirector_UnaryFunction1DVec2f(PyObject *self): UnaryFunction1D< Geometry::Vec2f >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D< Geometry::Vec2f > *)this, this); 
 }
 
 
 
 
-SwigDirector_UnaryFunction1DVec2f::SwigDirector_UnaryFunction1DVec2f(PyObject *self, IntegrationType iType): UnaryFunction1D<Geometry::Vec2f >(iType), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction1D<Geometry::Vec2f > *)this, this); 
+SwigDirector_UnaryFunction1DVec2f::SwigDirector_UnaryFunction1DVec2f(PyObject *self, IntegrationType iType): UnaryFunction1D< Geometry::Vec2f >(iType), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D< Geometry::Vec2f > *)this, this); 
 }
 
 
@@ -6515,11 +6534,11 @@ std::string SwigDirector_UnaryFunction1DVec2f::getName() const {
 }
 
 
-VecMat::Vec2<float > SwigDirector_UnaryFunction1DVec2f::operator ()(Interface1D &inter) {
+VecMat::Vec2< float > SwigDirector_UnaryFunction1DVec2f::operator ()(Interface1D &inter) {
   void *swig_argp ;
   int swig_res = 0 ;
   
-  VecMat::Vec2<float > c_result;
+  VecMat::Vec2< float > c_result;
   swig::PyObject_var obj0;
   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&inter), SWIGTYPE_p_Interface1D,  0 );
   if (!swig_get_self()) {
@@ -6539,25 +6558,25 @@ VecMat::Vec2<float > SwigDirector_UnaryFunction1DVec2f::operator ()(Interface1D
       Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction1DVec2f.__call__'");
     }
   }
-  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_VecMat__Vec2Tfloat_t,  0  | 0);
+  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_VecMat__Vec2T_float_t,  0  | 0);
   if (!SWIG_IsOK(swig_res)) {
-    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""VecMat::Vec2<float >""'");
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""VecMat::Vec2< float >""'");
   }
-  c_result = *(reinterpret_cast< VecMat::Vec2<float > * >(swig_argp));
-  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< VecMat::Vec2<float > * >(swig_argp);
-  return (VecMat::Vec2<float >) c_result;
+  c_result = *(reinterpret_cast< VecMat::Vec2< float > * >(swig_argp));
+  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< VecMat::Vec2< float > * >(swig_argp);
+  return (VecMat::Vec2< float >) c_result;
 }
 
 
-SwigDirector_UnaryFunction1DVec3f::SwigDirector_UnaryFunction1DVec3f(PyObject *self): UnaryFunction1D<Geometry::Vec3f >(), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction1D<Geometry::Vec3f > *)this, this); 
+SwigDirector_UnaryFunction1DVec3f::SwigDirector_UnaryFunction1DVec3f(PyObject *self): UnaryFunction1D< Geometry::Vec3f >(), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D< Geometry::Vec3f > *)this, this); 
 }
 
 
 
 
-SwigDirector_UnaryFunction1DVec3f::SwigDirector_UnaryFunction1DVec3f(PyObject *self, IntegrationType iType): UnaryFunction1D<Geometry::Vec3f >(iType), Swig::Director(self) {
-  SWIG_DIRECTOR_RGTR((UnaryFunction1D<Geometry::Vec3f > *)this, this); 
+SwigDirector_UnaryFunction1DVec3f::SwigDirector_UnaryFunction1DVec3f(PyObject *self, IntegrationType iType): UnaryFunction1D< Geometry::Vec3f >(iType), Swig::Director(self) {
+  SWIG_DIRECTOR_RGTR((UnaryFunction1D< Geometry::Vec3f > *)this, this); 
 }
 
 
@@ -6596,11 +6615,11 @@ std::string SwigDirector_UnaryFunction1DVec3f::getName() const {
 }
 
 
-VecMat::Vec3<float > SwigDirector_UnaryFunction1DVec3f::operator ()(Interface1D &inter) {
+VecMat::Vec3< float > SwigDirector_UnaryFunction1DVec3f::operator ()(Interface1D &inter) {
   void *swig_argp ;
   int swig_res = 0 ;
   
-  VecMat::Vec3<float > c_result;
+  VecMat::Vec3< float > c_result;
   swig::PyObject_var obj0;
   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&inter), SWIGTYPE_p_Interface1D,  0 );
   if (!swig_get_self()) {
@@ -6620,13 +6639,13 @@ VecMat::Vec3<float > SwigDirector_UnaryFunction1DVec3f::operator ()(Interface1D
       Swig::DirectorMethodException::raise("Error detected when calling 'UnaryFunction1DVec3f.__call__'");
     }
   }
-  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_VecMat__Vec3Tfloat_t,  0  | 0);
+  swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_VecMat__Vec3T_float_t,  0  | 0);
   if (!SWIG_IsOK(swig_res)) {
-    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""VecMat::Vec3<float >""'");
+    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""VecMat::Vec3< float >""'");
   }
-  c_result = *(reinterpret_cast< VecMat::Vec3<float > * >(swig_argp));
-  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< VecMat::Vec3<float > * >(swig_argp);
-  return (VecMat::Vec3<float >) c_result;
+  c_result = *(reinterpret_cast< VecMat::Vec3< float > * >(swig_argp));
+  if (SWIG_IsNewObj(swig_res)) delete reinterpret_cast< VecMat::Vec3< float > * >(swig_argp);
+  return (VecMat::Vec3< float >) c_result;
 }
 
 
@@ -6705,7 +6724,7 @@ ViewEdge *SwigDirector_ChainingIterator::operator *() {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
   }
   c_result = reinterpret_cast< ViewEdge * >(swig_argp);
-  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
   return (ViewEdge *) c_result;
 }
 
@@ -6738,7 +6757,7 @@ ViewEdge *SwigDirector_ChainingIterator::operator ->() {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
   }
   c_result = reinterpret_cast< ViewEdge * >(swig_argp);
-  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
   return (ViewEdge *) c_result;
 }
 
@@ -6976,7 +6995,7 @@ ViewEdge *SwigDirector_ChainingIterator::traverse(AdjacencyIterator const &it) {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
   }
   c_result = reinterpret_cast< ViewEdge * >(swig_argp);
-  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
   return (ViewEdge *) c_result;
 }
 
@@ -7056,7 +7075,7 @@ ViewEdge *SwigDirector_ChainSilhouetteIterator::operator *() {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
   }
   c_result = reinterpret_cast< ViewEdge * >(swig_argp);
-  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
   return (ViewEdge *) c_result;
 }
 
@@ -7089,7 +7108,7 @@ ViewEdge *SwigDirector_ChainSilhouetteIterator::operator ->() {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
   }
   c_result = reinterpret_cast< ViewEdge * >(swig_argp);
-  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
   return (ViewEdge *) c_result;
 }
 
@@ -7327,7 +7346,7 @@ ViewEdge *SwigDirector_ChainSilhouetteIterator::traverse(AdjacencyIterator const
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
   }
   c_result = reinterpret_cast< ViewEdge * >(swig_argp);
-  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
   return (ViewEdge *) c_result;
 }
 
@@ -7414,7 +7433,7 @@ ViewEdge *SwigDirector_ChainPredicateIterator::operator *() {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
   }
   c_result = reinterpret_cast< ViewEdge * >(swig_argp);
-  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
   return (ViewEdge *) c_result;
 }
 
@@ -7447,7 +7466,7 @@ ViewEdge *SwigDirector_ChainPredicateIterator::operator ->() {
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
   }
   c_result = reinterpret_cast< ViewEdge * >(swig_argp);
-  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
   return (ViewEdge *) c_result;
 }
 
@@ -7685,7 +7704,7 @@ ViewEdge *SwigDirector_ChainPredicateIterator::traverse(AdjacencyIterator const
     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""ViewEdge *""'");
   }
   c_result = reinterpret_cast< ViewEdge * >(swig_argp);
-  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
+  swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */);
   return (ViewEdge *) c_result;
 }
 
@@ -8104,7 +8123,7 @@ SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
   int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
+  argc = (int)PyObject_Length(args);
   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -8134,7 +8153,10 @@ SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *self, PyObject *args) {
   }
   
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_incr'.\n  Possible C/C++ prototypes are:\n    incr(size_t)\n    incr()\n");
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_incr'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    incr(swig::PySwigIterator *,size_t)\n"
+    "    incr(swig::PySwigIterator *)\n");
   return NULL;
 }
 
@@ -8218,7 +8240,7 @@ SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *self, PyObject *args) {
   int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
+  argc = (int)PyObject_Length(args);
   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -8248,7 +8270,10 @@ SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *self, PyObject *args) {
   }
   
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_decr'.\n  Possible C/C++ prototypes are:\n    decr(size_t)\n    decr()\n");
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'PySwigIterator_decr'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    decr(swig::PySwigIterator *,size_t)\n"
+    "    decr(swig::PySwigIterator *)\n");
   return NULL;
 }
 
@@ -8738,7 +8763,7 @@ SWIGINTERN PyObject *_wrap_PySwigIterator___sub__(PyObject *self, PyObject *args
   int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
+  argc = (int)PyObject_Length(args);
   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -8779,14 +8804,14 @@ fail:
 
 SWIGINTERN PyObject *PySwigIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
   SWIG_TypeNewClientData(SWIGTYPE_p_swig__PySwigIterator, SWIG_NewClientData(obj));
   return SWIG_Py_Void();
 }
 
 SWIGINTERN PyObject *_wrap_vectorInt_iterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
   PyObject **arg2 = (PyObject **) 0 ;
   swig::PySwigIterator *result = 0 ;
   void *argp1 = 0 ;
@@ -8795,11 +8820,11 @@ SWIGINTERN PyObject *_wrap_vectorInt_iterator(PyObject *SWIGUNUSEDPARM(self), Py
   
   arg2 = &obj0;
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_iterator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_iterator" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_iterator" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   result = (swig::PySwigIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
   return resultobj;
@@ -8810,19 +8835,19 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt___nonzero__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt___nonzero__",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt___nonzero__" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
-  result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector<int > const *)arg1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< int > const *)arg1);
   resultobj = SWIG_From_bool(static_cast< bool >(result));
   return resultobj;
 fail:
@@ -8832,19 +8857,19 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::size_type result;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::size_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt___len__",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt___len__" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___len__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
-  result = std_vector_Sl_int_Sg____len__((std::vector<int > const *)arg1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  result = std_vector_Sl_int_Sg____len__((std::vector< int > const *)arg1);
   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
   return resultobj;
 fail:
@@ -8854,20 +8879,20 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_pop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::value_type result;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_pop",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_pop" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_pop" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   try {
-    result = (std::vector<int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
+    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());
@@ -8882,10 +8907,10 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt___getslice__(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 > > *result = 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 > > *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
@@ -8897,29 +8922,29 @@ SWIGINTERN PyObject *_wrap_vectorInt___getslice__(PyObject *SWIGUNUSEDPARM(self)
   PyObject * obj2 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OOO:vectorInt___getslice__",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt___getslice__" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  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 '" "vectorInt___getslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt___getslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
   } 
-  arg2 = static_cast< std::vector<int >::difference_type >(val2);
+  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 '" "vectorInt___getslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt___getslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
   } 
-  arg3 = static_cast< std::vector<int >::difference_type >(val3);
+  arg3 = static_cast< std::vector< int >::difference_type >(val3);
   try {
-    result = (std::vector<int,std::allocator<int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3);
+    result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,arg2,arg3);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
   }
   
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -8928,10 +8953,10 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt___setslice__(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 ;
+  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 ;
@@ -8945,34 +8970,34 @@ SWIGINTERN PyObject *_wrap_vectorInt___setslice__(PyObject *SWIGUNUSEDPARM(self)
   PyObject * obj3 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OOOO:vectorInt___setslice__",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt___setslice__" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  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 '" "vectorInt___setslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
   } 
-  arg2 = static_cast< std::vector<int >::difference_type >(val2);
+  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 '" "vectorInt___setslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
   } 
-  arg3 = static_cast< std::vector<int >::difference_type >(val3);
+  arg3 = static_cast< std::vector< int >::difference_type >(val3);
   {
-    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;
     res4 = swig::asptr(obj3, &ptr);
     if (!SWIG_IsOK(res4)) {
-      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vectorInt___setslice__" "', argument " "4"" of type '" "std::vector<int,std::allocator<int > > const &""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "vectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
     }
     if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorInt___setslice__" "', argument " "4"" of type '" "std::vector<int,std::allocator<int > > const &""'"); 
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorInt___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
     }
     arg4 = ptr;
   }
   try {
-    std_vector_Sl_int_Sg____setslice__(arg1,arg2,arg3,(std::vector<int,std::allocator<int > > const &)*arg4);
+    std_vector_Sl_int_Sg____setslice__(arg1,arg2,arg3,(std::vector< int,std::allocator< int > > const &)*arg4);
   }
   catch(std::out_of_range &_e) {
     SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
@@ -8992,9 +9017,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt___delslice__(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 > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::difference_type arg2 ;
+  std::vector< int >::difference_type arg3 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
@@ -9006,21 +9031,21 @@ SWIGINTERN PyObject *_wrap_vectorInt___delslice__(PyObject *SWIGUNUSEDPARM(self)
   PyObject * obj2 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OOO:vectorInt___delslice__",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt___delslice__" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  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 '" "vectorInt___delslice__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt___delslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
   } 
-  arg2 = static_cast< std::vector<int >::difference_type >(val2);
+  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 '" "vectorInt___delslice__" "', argument " "3"" of type '" "std::vector<int >::difference_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt___delslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
   } 
-  arg3 = static_cast< std::vector<int >::difference_type >(val3);
+  arg3 = static_cast< std::vector< int >::difference_type >(val3);
   try {
     std_vector_Sl_int_Sg____delslice__(arg1,arg2,arg3);
   }
@@ -9037,8 +9062,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt___delitem__(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 > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::difference_type arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
@@ -9047,16 +9072,16 @@ SWIGINTERN PyObject *_wrap_vectorInt___delitem__(PyObject *SWIGUNUSEDPARM(self),
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt___delitem__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt___delitem__" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  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 '" "vectorInt___delitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt___delitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
   } 
-  arg2 = static_cast< std::vector<int >::difference_type >(val2);
+  arg2 = static_cast< std::vector< int >::difference_type >(val2);
   try {
     std_vector_Sl_int_Sg____delitem__(arg1,arg2);
   }
@@ -9073,9 +9098,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt___getitem__(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 >::value_type *result = 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::difference_type arg2 ;
+  std::vector< int >::value_type *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
@@ -9084,20 +9109,20 @@ SWIGINTERN PyObject *_wrap_vectorInt___getitem__(PyObject *SWIGUNUSEDPARM(self),
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt___getitem__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt___getitem__" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  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 '" "vectorInt___getitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt___getitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
   } 
-  arg2 = static_cast< std::vector<int >::difference_type >(val2);
+  arg2 = static_cast< std::vector< int >::difference_type >(val2);
   try {
     {
-      std::vector<int >::value_type const &_result_ref = std_vector_Sl_int_Sg____getitem__((std::vector<int > const *)arg1,arg2);
-      result = (std::vector<int >::value_type *) &_result_ref;
+      std::vector< int >::value_type const &_result_ref = std_vector_Sl_int_Sg____getitem__((std::vector< int > const *)arg1,arg2);
+      result = (std::vector< int >::value_type *) &_result_ref;
     }
   }
   catch(std::out_of_range &_e) {
@@ -9113,14 +9138,14 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt___setitem__(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 >::value_type *arg3 = 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::difference_type arg2 ;
+  std::vector< int >::value_type *arg3 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   ptrdiff_t val2 ;
   int ecode2 = 0 ;
-  std::vector<int >::value_type temp3 ;
+  std::vector< int >::value_type temp3 ;
   int val3 ;
   int ecode3 = 0 ;
   PyObject * obj0 = 0 ;
@@ -9128,21 +9153,21 @@ SWIGINTERN PyObject *_wrap_vectorInt___setitem__(PyObject *SWIGUNUSEDPARM(self),
   PyObject * obj2 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OOO:vectorInt___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt___setitem__" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  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 '" "vectorInt___setitem__" "', argument " "2"" of type '" "std::vector<int >::difference_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt___setitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
   } 
-  arg2 = static_cast< std::vector<int >::difference_type >(val2);
+  arg2 = static_cast< std::vector< int >::difference_type >(val2);
   ecode3 = SWIG_AsVal_int(obj2, &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt___setitem__" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt___setitem__" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
   } 
-  temp3 = static_cast< std::vector<int >::value_type >(val3);
+  temp3 = static_cast< std::vector< int >::value_type >(val3);
   arg3 = &temp3;
   try {
     std_vector_Sl_int_Sg____setitem__(arg1,arg2,(int const &)*arg3);
@@ -9160,27 +9185,27 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::value_type *arg2 = 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::value_type *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  std::vector<int >::value_type temp2 ;
+  std::vector< int >::value_type temp2 ;
   int val2 ;
   int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt_append",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_append" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_append" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   ecode2 = SWIG_AsVal_int(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_append" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
   } 
-  temp2 = static_cast< std::vector<int >::value_type >(val2);
+  temp2 = static_cast< std::vector< int >::value_type >(val2);
   arg2 = &temp2;
   std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2);
   resultobj = SWIG_Py_Void();
@@ -9192,11 +9217,11 @@ fail:
 
 SWIGINTERN PyObject *_wrap_new_vectorInt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *result = 0 ;
+  std::vector< int > *result = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)":new_vectorInt")) SWIG_fail;
-  result = (std::vector<int > *)new std::vector<int >();
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW |  0 );
+  result = (std::vector< int > *)new std::vector< int >();
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -9205,25 +9230,25 @@ fail:
 
 SWIGINTERN PyObject *_wrap_new_vectorInt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = 0 ;
-  std::vector<int > *result = 0 ;
+  std::vector< int > *arg1 = 0 ;
+  std::vector< int > *result = 0 ;
   int res1 = SWIG_OLDOBJ ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:new_vectorInt",&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_vectorInt" "', argument " "1"" of type '" "std::vector<int > const &""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_vectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
     }
     if (!ptr) {
-      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectorInt" "', argument " "1"" of type '" "std::vector<int > const &""'"); 
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_vectorInt" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
     }
     arg1 = ptr;
   }
-  result = (std::vector<int > *)new std::vector<int >((std::vector<int > const &)*arg1);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW |  0 );
+  result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
   if (SWIG_IsNewObj(res1)) delete arg1;
   return resultobj;
 fail:
@@ -9234,19 +9259,19 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_empty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_empty",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_empty" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_empty" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
-  result = (bool)((std::vector<int > const *)arg1)->empty();
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  result = (bool)((std::vector< int > const *)arg1)->empty();
   resultobj = SWIG_From_bool(static_cast< bool >(result));
   return resultobj;
 fail:
@@ -9256,19 +9281,19 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::size_type result;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::size_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_size",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_size" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_size" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
-  result = ((std::vector<int > const *)arg1)->size();
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  result = ((std::vector< int > const *)arg1)->size();
   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
   return resultobj;
 fail:
@@ -9278,17 +9303,17 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_clear",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_clear" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   (arg1)->clear();
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -9299,8 +9324,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int > *arg2 = 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int > *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -9309,19 +9334,19 @@ SWIGINTERN PyObject *_wrap_vectorInt_swap(PyObject *SWIGUNUSEDPARM(self), PyObje
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt_swap",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_swap" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_swap" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t,  0 );
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorInt_swap" "', argument " "2"" of type '" "std::vector<int > &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "vectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorInt_swap" "', argument " "2"" of type '" "std::vector<int > &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "vectorInt_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); 
   }
-  arg2 = reinterpret_cast< std::vector<int > * >(argp2);
+  arg2 = reinterpret_cast< std::vector< int > * >(argp2);
   (arg1)->swap(*arg2);
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -9332,42 +9357,42 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_get_allocator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  SwigValueWrapper<std::allocator<int > > result;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  SwigValueWrapper< std::allocator< int > > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_get_allocator",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_get_allocator" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_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__vectorTint_std__allocatorTint_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
+  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__vectorT_int_std__allocatorT_int_t_t__allocator_type, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
 }
 
 
-SWIGINTERN PyObject *_wrap_vectorInt_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vectorInt_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::iterator result;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::const_iterator result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_begin",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_begin" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_begin" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
-  result = (arg1)->begin();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  result = ((std::vector< int > const *)arg1)->begin();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_iterator & >(result)),
     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
 fail:
@@ -9375,101 +9400,22 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vectorInt_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vectorInt_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::const_iterator result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_begin",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_begin" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
-  result = ((std::vector<int > const *)arg1)->begin();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_iterator & >(result)),
-    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vectorInt_begin(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[2];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 1) {
-    int _v;
-    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_vectorInt_begin__SWIG_0(self, args);
-    }
-  }
-  if (argc == 1) {
-    int _v;
-    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_vectorInt_begin__SWIG_1(self, args);
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_begin'.\n  Possible C/C++ prototypes are:\n    begin()\n    begin()\n");
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vectorInt_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::iterator result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_end",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_end" "', argument " "1"" of type '" "std::vector<int > *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
-  result = (arg1)->end();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
-    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vectorInt_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::const_iterator result;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::const_iterator result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_end",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_end" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_end" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
-  result = ((std::vector<int > const *)arg1)->end();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_iterator & >(result)),
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  result = ((std::vector< int > const *)arg1)->end();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_iterator & >(result)),
     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
 fail:
@@ -9477,55 +9423,22 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vectorInt_end(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[2];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 1) {
-    int _v;
-    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_vectorInt_end__SWIG_0(self, args);
-    }
-  }
-  if (argc == 1) {
-    int _v;
-    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_vectorInt_end__SWIG_1(self, args);
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_end'.\n  Possible C/C++ prototypes are:\n    end()\n    end()\n");
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vectorInt_rbegin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vectorInt_rbegin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::reverse_iterator result;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::const_reverse_iterator result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_rbegin",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_rbegin" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_rbegin" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
-  result = (arg1)->rbegin();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::reverse_iterator & >(result)),
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  result = ((std::vector< int > const *)arg1)->rbegin();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_reverse_iterator & >(result)),
     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
 fail:
@@ -9533,78 +9446,22 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vectorInt_rbegin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_vectorInt_rend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::const_reverse_iterator result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_rbegin",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_rbegin" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
-  result = ((std::vector<int > const *)arg1)->rbegin();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_reverse_iterator & >(result)),
-    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vectorInt_rbegin(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[2];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 1) {
-    int _v;
-    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_vectorInt_rbegin__SWIG_0(self, args);
-    }
-  }
-  if (argc == 1) {
-    int _v;
-    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_vectorInt_rbegin__SWIG_1(self, args);
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_rbegin'.\n  Possible C/C++ prototypes are:\n    rbegin()\n    rbegin()\n");
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vectorInt_rend__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::reverse_iterator result;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::const_reverse_iterator result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_rend",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_rend" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_rend" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
-  result = (arg1)->rend();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::reverse_iterator & >(result)),
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  result = ((std::vector< int > const *)arg1)->rend();
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::const_reverse_iterator & >(result)),
     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
 fail:
@@ -9612,66 +9469,10 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_vectorInt_rend__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::const_reverse_iterator result;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  PyObject * obj0 = 0 ;
-  
-  if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_rend",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_rend" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
-  }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
-  result = ((std::vector<int > const *)arg1)->rend();
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::const_reverse_iterator & >(result)),
-    swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_vectorInt_rend(PyObject *self, PyObject *args) {
-  int argc;
-  PyObject *argv[2];
-  int ii;
-  
-  if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
-  for (ii = 0; (ii < argc) && (ii < 1); ii++) {
-    argv[ii] = PyTuple_GET_ITEM(args,ii);
-  }
-  if (argc == 1) {
-    int _v;
-    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_vectorInt_rend__SWIG_0(self, args);
-    }
-  }
-  if (argc == 1) {
-    int _v;
-    int res = swig::asptr(argv[0], (std::vector<int,std::allocator<int > >**)(0));
-    _v = SWIG_CheckState(res);
-    if (_v) {
-      return _wrap_vectorInt_rend__SWIG_1(self, args);
-    }
-  }
-  
-fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_rend'.\n  Possible C/C++ prototypes are:\n    rend()\n    rend()\n");
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_new_vectorInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int >::size_type arg1 ;
-  std::vector<int > *result = 0 ;
+  std::vector< int >::size_type arg1 ;
+  std::vector< int > *result = 0 ;
   size_t val1 ;
   int ecode1 = 0 ;
   PyObject * obj0 = 0 ;
@@ -9679,11 +9480,11 @@ SWIGINTERN PyObject *_wrap_new_vectorInt__SWIG_2(PyObject *SWIGUNUSEDPARM(self),
   if (!PyArg_ParseTuple(args,(char *)"O:new_vectorInt",&obj0)) SWIG_fail;
   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_vectorInt" "', argument " "1"" of type '" "std::vector<int >::size_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_vectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
   } 
-  arg1 = static_cast< std::vector<int >::size_type >(val1);
-  result = (std::vector<int > *)new std::vector<int >(arg1);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW |  0 );
+  arg1 = static_cast< std::vector< int >::size_type >(val1);
+  result = (std::vector< int > *)new std::vector< int >(arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -9692,17 +9493,17 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_pop_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_pop_back",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_pop_back" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   (arg1)->pop_back();
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -9713,8 +9514,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::size_type arg2 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::size_type arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   size_t val2 ;
@@ -9723,16 +9524,16 @@ SWIGINTERN PyObject *_wrap_vectorInt_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(sel
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt_resize",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_resize" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_resize" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
   } 
-  arg2 = static_cast< std::vector<int >::size_type >(val2);
+  arg2 = static_cast< std::vector< int >::size_type >(val2);
   (arg1)->resize(arg2);
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -9743,9 +9544,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::iterator arg2 ;
-  std::vector<int >::iterator result;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::iterator arg2 ;
+  std::vector< int >::iterator result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   swig::PySwigIterator *iter2 = 0 ;
@@ -9754,24 +9555,24 @@ SWIGINTERN PyObject *_wrap_vectorInt_erase__SWIG_0(PyObject *SWIGUNUSEDPARM(self
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt_erase",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_erase" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
   if (!SWIG_IsOK(res2) || !iter2) {
-    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
   } else {
-    swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
+    swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter2);
     if (iter_t) {
       arg2 = iter_t->get_current();
     } else {
-      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
     }
   }
   result = (arg1)->erase(arg2);
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
 fail:
@@ -9781,10 +9582,10 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::iterator arg2 ;
-  std::vector<int >::iterator arg3 ;
-  std::vector<int >::iterator result;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::iterator arg2 ;
+  std::vector< int >::iterator arg3 ;
+  std::vector< int >::iterator result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   swig::PySwigIterator *iter2 = 0 ;
@@ -9796,35 +9597,35 @@ SWIGINTERN PyObject *_wrap_vectorInt_erase__SWIG_1(PyObject *SWIGUNUSEDPARM(self
   PyObject * obj2 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OOO:vectorInt_erase",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_erase" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
   if (!SWIG_IsOK(res2) || !iter2) {
-    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
   } else {
-    swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
+    swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter2);
     if (iter_t) {
       arg2 = iter_t->get_current();
     } else {
-      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
     }
   }
   res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&iter3), swig::PySwigIterator::descriptor(), 0);
   if (!SWIG_IsOK(res3) || !iter3) {
-    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "3"" of type '" "std::vector<int >::iterator""'");
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
   } else {
-    swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter3);
+    swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter3);
     if (iter_t) {
       arg3 = iter_t->get_current();
     } else {
-      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "3"" of type '" "std::vector<int >::iterator""'");
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
     }
   }
   result = (arg1)->erase(arg2,arg3);
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
 fail:
@@ -9838,18 +9639,18 @@ SWIGINTERN PyObject *_wrap_vectorInt_erase(PyObject *self, PyObject *args) {
   int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
+  argc = (int)PyObject_Length(args);
   for (ii = 0; (ii < argc) && (ii < 3); 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::PySwigIterator *iter = 0;
       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
-      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
       if (_v) {
         return _wrap_vectorInt_erase__SWIG_0(self, args);
       }
@@ -9857,16 +9658,16 @@ SWIGINTERN PyObject *_wrap_vectorInt_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::PySwigIterator *iter = 0;
       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
-      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
       if (_v) {
         swig::PySwigIterator *iter = 0;
         int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
-        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
         if (_v) {
           return _wrap_vectorInt_erase__SWIG_1(self, args);
         }
@@ -9875,19 +9676,22 @@ SWIGINTERN PyObject *_wrap_vectorInt_erase(PyObject *self, PyObject *args) {
   }
   
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_erase'.\n  Possible C/C++ prototypes are:\n    erase(std::vector<int >::iterator)\n    erase(std::vector<int >::iterator,std::vector<int >::iterator)\n");
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_erase'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    erase(std::vector< int > *,std::vector< int >::iterator)\n"
+    "    erase(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::iterator)\n");
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_new_vectorInt__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int >::size_type arg1 ;
-  std::vector<int >::value_type *arg2 = 0 ;
-  std::vector<int > *result = 0 ;
+  std::vector< int >::size_type arg1 ;
+  std::vector< int >::value_type *arg2 = 0 ;
+  std::vector< int > *result = 0 ;
   size_t val1 ;
   int ecode1 = 0 ;
-  std::vector<int >::value_type temp2 ;
+  std::vector< int >::value_type temp2 ;
   int val2 ;
   int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
@@ -9896,17 +9700,17 @@ SWIGINTERN PyObject *_wrap_new_vectorInt__SWIG_3(PyObject *SWIGUNUSEDPARM(self),
   if (!PyArg_ParseTuple(args,(char *)"OO:new_vectorInt",&obj0,&obj1)) SWIG_fail;
   ecode1 = SWIG_AsVal_size_t(obj0, &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_vectorInt" "', argument " "1"" of type '" "std::vector<int >::size_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_vectorInt" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
   } 
-  arg1 = static_cast< std::vector<int >::size_type >(val1);
+  arg1 = static_cast< std::vector< int >::size_type >(val1);
   ecode2 = SWIG_AsVal_int(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_vectorInt" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_vectorInt" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
   } 
-  temp2 = static_cast< std::vector<int >::value_type >(val2);
+  temp2 = static_cast< std::vector< int >::value_type >(val2);
   arg2 = &temp2;
-  result = (std::vector<int > *)new std::vector<int >(arg1,(std::vector<int >::value_type const &)*arg2);
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_NEW |  0 );
+  result = (std::vector< int > *)new std::vector< int >(arg1,(std::vector< int >::value_type const &)*arg2);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -9919,7 +9723,7 @@ SWIGINTERN PyObject *_wrap_new_vectorInt(PyObject *self, PyObject *args) {
   int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
+  argc = (int)PyObject_Length(args);
   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -9938,7 +9742,7 @@ SWIGINTERN PyObject *_wrap_new_vectorInt(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_vectorInt__SWIG_1(self, args);
@@ -9962,36 +9766,41 @@ SWIGINTERN PyObject *_wrap_new_vectorInt(PyObject *self, PyObject *args) {
   }
   
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_vectorInt'.\n  Possible C/C++ prototypes are:\n    std::vector<(int)>()\n    std::vector<(int)>(std::vector<int > const &)\n    std::vector<(int)>(std::vector<int >::size_type)\n    std::vector<(int)>(std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_vectorInt'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    std::vector< int >()\n"
+    "    std::vector< int >(std::vector< int > const &)\n"
+    "    std::vector< int >(std::vector< int >::size_type)\n"
+    "    std::vector< int >(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_vectorInt_push_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::value_type *arg2 = 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::value_type *arg2 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
-  std::vector<int >::value_type temp2 ;
+  std::vector< int >::value_type temp2 ;
   int val2 ;
   int ecode2 = 0 ;
   PyObject * obj0 = 0 ;
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt_push_back",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_push_back" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_push_back" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   ecode2 = SWIG_AsVal_int(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_push_back" "', argument " "2"" of type '" "std::vector<int >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
   } 
-  temp2 = static_cast< std::vector<int >::value_type >(val2);
+  temp2 = static_cast< std::vector< int >::value_type >(val2);
   arg2 = &temp2;
-  (arg1)->push_back((std::vector<int >::value_type const &)*arg2);
+  (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -10001,21 +9810,21 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_front(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::value_type *result = 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::value_type *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_front",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_front" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_front" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   {
-    std::vector<int >::value_type const &_result_ref = ((std::vector<int > const *)arg1)->front();
-    result = (std::vector<int >::value_type *) &_result_ref;
+    std::vector< int >::value_type const &_result_ref = ((std::vector< int > const *)arg1)->front();
+    result = (std::vector< int >::value_type *) &_result_ref;
   }
   resultobj = SWIG_From_int(static_cast< int >(*result));
   return resultobj;
@@ -10026,21 +9835,21 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::value_type *result = 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::value_type *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_back",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_back" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_back" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   {
-    std::vector<int >::value_type const &_result_ref = ((std::vector<int > const *)arg1)->back();
-    result = (std::vector<int >::value_type *) &_result_ref;
+    std::vector< int >::value_type const &_result_ref = ((std::vector< int > const *)arg1)->back();
+    result = (std::vector< int >::value_type *) &_result_ref;
   }
   resultobj = SWIG_From_int(static_cast< int >(*result));
   return resultobj;
@@ -10051,14 +9860,14 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::size_type arg2 ;
-  std::vector<int >::value_type *arg3 = 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::size_type arg2 ;
+  std::vector< int >::value_type *arg3 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   size_t val2 ;
   int ecode2 = 0 ;
-  std::vector<int >::value_type temp3 ;
+  std::vector< int >::value_type temp3 ;
   int val3 ;
   int ecode3 = 0 ;
   PyObject * obj0 = 0 ;
@@ -10066,23 +9875,23 @@ SWIGINTERN PyObject *_wrap_vectorInt_assign(PyObject *SWIGUNUSEDPARM(self), PyOb
   PyObject * obj2 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OOO:vectorInt_assign",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_assign" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_assign" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_assign" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
   } 
-  arg2 = static_cast< std::vector<int >::size_type >(val2);
+  arg2 = static_cast< std::vector< int >::size_type >(val2);
   ecode3 = SWIG_AsVal_int(obj2, &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt_assign" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
   } 
-  temp3 = static_cast< std::vector<int >::value_type >(val3);
+  temp3 = static_cast< std::vector< int >::value_type >(val3);
   arg3 = &temp3;
-  (arg1)->assign(arg2,(std::vector<int >::value_type const &)*arg3);
+  (arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3);
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -10092,14 +9901,14 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::size_type arg2 ;
-  std::vector<int >::value_type *arg3 = 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::size_type arg2 ;
+  std::vector< int >::value_type *arg3 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   size_t val2 ;
   int ecode2 = 0 ;
-  std::vector<int >::value_type temp3 ;
+  std::vector< int >::value_type temp3 ;
   int val3 ;
   int ecode3 = 0 ;
   PyObject * obj0 = 0 ;
@@ -10107,23 +9916,23 @@ SWIGINTERN PyObject *_wrap_vectorInt_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(sel
   PyObject * obj2 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OOO:vectorInt_resize",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_resize" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_resize" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
   } 
-  arg2 = static_cast< std::vector<int >::size_type >(val2);
+  arg2 = static_cast< std::vector< int >::size_type >(val2);
   ecode3 = SWIG_AsVal_int(obj2, &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt_resize" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
   } 
-  temp3 = static_cast< std::vector<int >::value_type >(val3);
+  temp3 = static_cast< std::vector< int >::value_type >(val3);
   arg3 = &temp3;
-  (arg1)->resize(arg2,(std::vector<int >::value_type const &)*arg3);
+  (arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3);
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -10137,13 +9946,13 @@ SWIGINTERN PyObject *_wrap_vectorInt_resize(PyObject *self, PyObject *args) {
   int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
+  argc = (int)PyObject_Length(args);
   for (ii = 0; (ii < argc) && (ii < 3); 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) {
       {
@@ -10157,7 +9966,7 @@ SWIGINTERN PyObject *_wrap_vectorInt_resize(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) {
       {
@@ -10177,22 +9986,25 @@ SWIGINTERN PyObject *_wrap_vectorInt_resize(PyObject *self, PyObject *args) {
   }
   
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_resize'.\n  Possible C/C++ prototypes are:\n    resize(std::vector<int >::size_type)\n    resize(std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_resize'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    resize(std::vector< int > *,std::vector< int >::size_type)\n"
+    "    resize(std::vector< int > *,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_vectorInt_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::iterator arg2 ;
-  std::vector<int >::value_type *arg3 = 0 ;
-  std::vector<int >::iterator result;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::iterator arg2 ;
+  std::vector< int >::value_type *arg3 = 0 ;
+  std::vector< int >::iterator result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   swig::PySwigIterator *iter2 = 0 ;
   int res2 ;
-  std::vector<int >::value_type temp3 ;
+  std::vector< int >::value_type temp3 ;
   int val3 ;
   int ecode3 = 0 ;
   PyObject * obj0 = 0 ;
@@ -10200,30 +10012,30 @@ SWIGINTERN PyObject *_wrap_vectorInt_insert__SWIG_0(PyObject *SWIGUNUSEDPARM(sel
   PyObject * obj2 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OOO:vectorInt_insert",&obj0,&obj1,&obj2)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_insert" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
   if (!SWIG_IsOK(res2) || !iter2) {
-    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
   } else {
-    swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
+    swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter2);
     if (iter_t) {
       arg2 = iter_t->get_current();
     } else {
-      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
     }
   }
   ecode3 = SWIG_AsVal_int(obj2, &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt_insert" "', argument " "3"" of type '" "std::vector<int >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
   } 
-  temp3 = static_cast< std::vector<int >::value_type >(val3);
+  temp3 = static_cast< std::vector< int >::value_type >(val3);
   arg3 = &temp3;
-  result = (arg1)->insert(arg2,(std::vector<int >::value_type const &)*arg3);
-  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector<int >::iterator & >(result)),
+  result = (arg1)->insert(arg2,(std::vector< int >::value_type const &)*arg3);
+  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
     swig::PySwigIterator::descriptor(),SWIG_POINTER_OWN);
   return resultobj;
 fail:
@@ -10233,17 +10045,17 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::iterator arg2 ;
-  std::vector<int >::size_type arg3 ;
-  std::vector<int >::value_type *arg4 = 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::iterator arg2 ;
+  std::vector< int >::size_type arg3 ;
+  std::vector< int >::value_type *arg4 = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   swig::PySwigIterator *iter2 = 0 ;
   int res2 ;
   size_t val3 ;
   int ecode3 = 0 ;
-  std::vector<int >::value_type temp4 ;
+  std::vector< int >::value_type temp4 ;
   int val4 ;
   int ecode4 = 0 ;
   PyObject * obj0 = 0 ;
@@ -10252,34 +10064,34 @@ SWIGINTERN PyObject *_wrap_vectorInt_insert__SWIG_1(PyObject *SWIGUNUSEDPARM(sel
   PyObject * obj3 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OOOO:vectorInt_insert",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_insert" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&iter2), swig::PySwigIterator::descriptor(), 0);
   if (!SWIG_IsOK(res2) || !iter2) {
-    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
   } else {
-    swig::PySwigIterator_T<std::vector<int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter2);
+    swig::PySwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter2);
     if (iter_t) {
       arg2 = iter_t->get_current();
     } else {
-      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_insert" "', argument " "2"" of type '" "std::vector<int >::iterator""'");
+      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "vectorInt_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
     }
   }
   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
   if (!SWIG_IsOK(ecode3)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt_insert" "', argument " "3"" of type '" "std::vector<int >::size_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vectorInt_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'");
   } 
-  arg3 = static_cast< std::vector<int >::size_type >(val3);
+  arg3 = static_cast< std::vector< int >::size_type >(val3);
   ecode4 = SWIG_AsVal_int(obj3, &val4);
   if (!SWIG_IsOK(ecode4)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vectorInt_insert" "', argument " "4"" of type '" "std::vector<int >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vectorInt_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'");
   } 
-  temp4 = static_cast< std::vector<int >::value_type >(val4);
+  temp4 = static_cast< std::vector< int >::value_type >(val4);
   arg4 = &temp4;
-  (arg1)->insert(arg2,arg3,(std::vector<int >::value_type const &)*arg4);
+  (arg1)->insert(arg2,arg3,(std::vector< int >::value_type const &)*arg4);
   resultobj = SWIG_Py_Void();
   return resultobj;
 fail:
@@ -10293,18 +10105,18 @@ SWIGINTERN PyObject *_wrap_vectorInt_insert(PyObject *self, PyObject *args) {
   int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
+  argc = (int)PyObject_Length(args);
   for (ii = 0; (ii < argc) && (ii < 4); 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::PySwigIterator *iter = 0;
       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
-      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
       if (_v) {
         {
           int res = SWIG_AsVal_int(argv[2], NULL);
@@ -10318,12 +10130,12 @@ SWIGINTERN PyObject *_wrap_vectorInt_insert(PyObject *self, PyObject *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) {
       swig::PySwigIterator *iter = 0;
       int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::PySwigIterator::descriptor(), 0);
-      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector<int >::iterator > *>(iter) != 0));
+      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::PySwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
       if (_v) {
         {
           int res = SWIG_AsVal_size_t(argv[2], NULL);
@@ -10343,15 +10155,18 @@ SWIGINTERN PyObject *_wrap_vectorInt_insert(PyObject *self, PyObject *args) {
   }
   
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_insert'.\n  Possible C/C++ prototypes are:\n    insert(std::vector<int >::iterator,std::vector<int >::value_type const &)\n    insert(std::vector<int >::iterator,std::vector<int >::size_type,std::vector<int >::value_type const &)\n");
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'vectorInt_insert'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    insert(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::value_type const &)\n"
+    "    insert(std::vector< int > *,std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_vectorInt_reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::size_type arg2 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::size_type arg2 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   size_t val2 ;
@@ -10360,16 +10175,16 @@ SWIGINTERN PyObject *_wrap_vectorInt_reserve(PyObject *SWIGUNUSEDPARM(self), PyO
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:vectorInt_reserve",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_reserve" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_reserve" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_reserve" "', argument " "2"" of type '" "std::vector<int >::size_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vectorInt_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
   } 
-  arg2 = static_cast< std::vector<int >::size_type >(val2);
+  arg2 = static_cast< std::vector< int >::size_type >(val2);
   (arg1)->reserve(arg2);
   resultobj = SWIG_Py_Void();
   return resultobj;
@@ -10380,19 +10195,19 @@ fail:
 
 SWIGINTERN PyObject *_wrap_vectorInt_capacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
-  std::vector<int >::size_type result;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
+  std::vector< int >::size_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:vectorInt_capacity",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, 0 |  0 );
+  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 '" "vectorInt_capacity" "', argument " "1"" of type '" "std::vector<int > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "vectorInt_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
-  result = ((std::vector<int > const *)arg1)->capacity();
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
+  result = ((std::vector< int > const *)arg1)->capacity();
   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
   return resultobj;
 fail:
@@ -10402,17 +10217,17 @@ fail:
 
 SWIGINTERN PyObject *_wrap_delete_vectorInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  std::vector<int > *arg1 = (std::vector<int > *) 0 ;
+  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:delete_vectorInt",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_POINTER_DISOWN |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_POINTER_DISOWN |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vectorInt" "', argument " "1"" of type '" "std::vector<int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_vectorInt" "', argument " "1"" of type '" "std::vector< int > *""'"); 
   }
-  arg1 = reinterpret_cast< std::vector<int > * >(argp1);
+  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
   {
     try {
       delete arg1;
@@ -10434,8 +10249,8 @@ fail:
 
 SWIGINTERN PyObject *vectorInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorTint_std__allocatorTint_t_t, SWIG_NewClientData(obj));
+  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, SWIG_NewClientData(obj));
   return SWIG_Py_Void();
 }
 
@@ -10576,7 +10391,7 @@ SWIGINTERN PyObject *_wrap_new_Id(PyObject *self, PyObject *args) {
   int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
+  argc = (int)PyObject_Length(args);
   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -10619,7 +10434,12 @@ SWIGINTERN PyObject *_wrap_new_Id(PyObject *self, PyObject *args) {
   }
   
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Id'.\n  Possible C/C++ prototypes are:\n    Id()\n    Id(Id::id_type)\n    Id(Id::id_type,Id::id_type)\n    Id(Id const &)\n");
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Id'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    Id()\n"
+    "    Id(Id::id_type)\n"
+    "    Id(Id::id_type,Id::id_type)\n"
+    "    Id(Id const &)\n");
   return NULL;
 }
 
@@ -10934,19 +10754,19 @@ fail:
 
 SWIGINTERN PyObject *Id_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
+  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
   SWIG_TypeNewClientData(SWIGTYPE_p_Id, SWIG_NewClientData(obj));
   return SWIG_Py_Void();
 }
 
 SWIGINTERN PyObject *_wrap_new_Vec_2u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *result = 0 ;
+  VecMat::Vec< unsigned int,2 > *result = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)":new_Vec_2u")) SWIG_fail;
   {
     try {
-      result = (VecMat::Vec<unsigned int,2 > *)new VecMat::Vec<unsigned int,2 >();
+      result = (VecMat::Vec< unsigned int,2 > *)new VecMat::Vec< unsigned int,2 >();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -10955,7 +10775,7 @@ SWIGINTERN PyObject *_wrap_new_Vec_2u(PyObject *SWIGUNUSEDPARM(self), PyObject *
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, SWIG_POINTER_NEW |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -10964,17 +10784,17 @@ fail:
 
 SWIGINTERN PyObject *_wrap_delete_Vec_2u(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
+  VecMat::Vec< unsigned int,2 > *arg1 = (VecMat::Vec< unsigned int,2 > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec_2u",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, SWIG_POINTER_DISOWN |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, SWIG_POINTER_DISOWN |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_2u" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_2u" "', argument " "1"" of type '" "VecMat::Vec< unsigned int,2 > *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp1);
   {
     try {
       delete arg1;
@@ -11001,7 +10821,7 @@ SWIGINTERN PyObject *_wrap_Vec_2u_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *
   if (!PyArg_ParseTuple(args,(char *)":Vec_2u_dim")) SWIG_fail;
   {
     try {
-      result = (unsigned int)VecMat::Vec<unsigned int,2 >::SWIGTEMPLATEDISAMBIGUATOR dim();
+      result = (unsigned int)VecMat::Vec< unsigned int,2 >::SWIGTEMPLATEDISAMBIGUATOR dim();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11019,21 +10839,21 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2u_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
-  VecMat::Vec<unsigned int,2 >::value_type result;
+  VecMat::Vec< unsigned int,2 > *arg1 = (VecMat::Vec< unsigned int,2 > *) 0 ;
+  VecMat::Vec< unsigned int,2 >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2u_norm",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u_norm" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u_norm" "', argument " "1"" of type '" "VecMat::Vec< unsigned int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp1);
   {
     try {
-      result = (VecMat::Vec<unsigned int,2 >::value_type)((VecMat::Vec<unsigned int,2 > const *)arg1)->norm();
+      result = (VecMat::Vec< unsigned int,2 >::value_type)((VecMat::Vec< unsigned int,2 > const *)arg1)->norm();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11051,21 +10871,21 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2u_squareNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
-  VecMat::Vec<unsigned int,2 >::value_type result;
+  VecMat::Vec< unsigned int,2 > *arg1 = (VecMat::Vec< unsigned int,2 > *) 0 ;
+  VecMat::Vec< unsigned int,2 >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2u_squareNorm",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u_squareNorm" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u_squareNorm" "', argument " "1"" of type '" "VecMat::Vec< unsigned int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp1);
   {
     try {
-      result = (VecMat::Vec<unsigned int,2 >::value_type)((VecMat::Vec<unsigned int,2 > const *)arg1)->squareNorm();
+      result = (VecMat::Vec< unsigned int,2 >::value_type)((VecMat::Vec< unsigned int,2 > const *)arg1)->squareNorm();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11083,23 +10903,23 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2u_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
-  VecMat::Vec<unsigned int,2 > *result = 0 ;
+  VecMat::Vec< unsigned int,2 > *arg1 = (VecMat::Vec< unsigned int,2 > *) 0 ;
+  VecMat::Vec< unsigned int,2 > *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2u_normalize",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u_normalize" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u_normalize" "', argument " "1"" of type '" "VecMat::Vec< unsigned int,2 > *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp1);
   {
     try {
       {
-        VecMat::Vec<unsigned int,2 > &_result_ref = (arg1)->normalize();
-        result = (VecMat::Vec<unsigned int,2 > *) &_result_ref;
+        VecMat::Vec< unsigned int,2 > &_result_ref = (arg1)->normalize();
+        result = (VecMat::Vec< unsigned int,2 > *) &_result_ref;
       }
     }
     //    catch (Swig::DirectorTypeMismatch&) {
@@ -11109,7 +10929,7 @@ SWIGINTERN PyObject *_wrap_Vec_2u_normalize(PyObject *SWIGUNUSEDPARM(self), PyOb
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -11118,23 +10938,23 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2u_normalizeSafe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
-  VecMat::Vec<unsigned int,2 > *result = 0 ;
+  VecMat::Vec< unsigned int,2 > *arg1 = (VecMat::Vec< unsigned int,2 > *) 0 ;
+  VecMat::Vec< unsigned int,2 > *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2u_normalizeSafe",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec< unsigned int,2 > *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp1);
   {
     try {
       {
-        VecMat::Vec<unsigned int,2 > &_result_ref = (arg1)->normalizeSafe();
-        result = (VecMat::Vec<unsigned int,2 > *) &_result_ref;
+        VecMat::Vec< unsigned int,2 > &_result_ref = (arg1)->normalizeSafe();
+        result = (VecMat::Vec< unsigned int,2 > *) &_result_ref;
       }
     }
     //    catch (Swig::DirectorTypeMismatch&) {
@@ -11144,7 +10964,7 @@ SWIGINTERN PyObject *_wrap_Vec_2u_normalizeSafe(PyObject *SWIGUNUSEDPARM(self),
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -11153,9 +10973,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2u___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
-  VecMat::Vec<unsigned int,2 > *arg2 = 0 ;
-  VecMat::Vec<unsigned int,2 > result;
+  VecMat::Vec< unsigned int,2 > *arg1 = (VecMat::Vec< unsigned int,2 > *) 0 ;
+  VecMat::Vec< unsigned int,2 > *arg2 = 0 ;
+  VecMat::Vec< unsigned int,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -11164,22 +10984,22 @@ SWIGINTERN PyObject *_wrap_Vec_2u___add__(PyObject *SWIGUNUSEDPARM(self), PyObje
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___add__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___add__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___add__" "', argument " "1"" of type '" "VecMat::Vec< unsigned int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___add__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___add__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___add__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___add__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp2);
   {
     try {
-      result = ((VecMat::Vec<unsigned int,2 > const *)arg1)->operator +((VecMat::Vec<unsigned int,2 > const &)*arg2);
+      result = ((VecMat::Vec< unsigned int,2 > const *)arg1)->operator +((VecMat::Vec< unsigned int,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11188,7 +11008,7 @@ SWIGINTERN PyObject *_wrap_Vec_2u___add__(PyObject *SWIGUNUSEDPARM(self), PyObje
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<unsigned int,2 >(static_cast< const VecMat::Vec<unsigned int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< unsigned int,2 >(static_cast< const VecMat::Vec< unsigned int,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -11197,9 +11017,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2u___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
-  VecMat::Vec<unsigned int,2 > *arg2 = 0 ;
-  VecMat::Vec<unsigned int,2 > result;
+  VecMat::Vec< unsigned int,2 > *arg1 = (VecMat::Vec< unsigned int,2 > *) 0 ;
+  VecMat::Vec< unsigned int,2 > *arg2 = 0 ;
+  VecMat::Vec< unsigned int,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -11208,22 +11028,22 @@ SWIGINTERN PyObject *_wrap_Vec_2u___sub__(PyObject *SWIGUNUSEDPARM(self), PyObje
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___sub__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___sub__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___sub__" "', argument " "1"" of type '" "VecMat::Vec< unsigned int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___sub__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___sub__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___sub__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___sub__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp2);
   {
     try {
-      result = ((VecMat::Vec<unsigned int,2 > const *)arg1)->operator -((VecMat::Vec<unsigned int,2 > const &)*arg2);
+      result = ((VecMat::Vec< unsigned int,2 > const *)arg1)->operator -((VecMat::Vec< unsigned int,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11232,7 +11052,7 @@ SWIGINTERN PyObject *_wrap_Vec_2u___sub__(PyObject *SWIGUNUSEDPARM(self), PyObje
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<unsigned int,2 >(static_cast< const VecMat::Vec<unsigned int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< unsigned int,2 >(static_cast< const VecMat::Vec< unsigned int,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -11241,9 +11061,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2u___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
-  VecMat::Vec<unsigned int,2 >::value_type arg2 ;
-  VecMat::Vec<unsigned int,2 > result;
+  VecMat::Vec< unsigned int,2 > *arg1 = (VecMat::Vec< unsigned int,2 > *) 0 ;
+  VecMat::Vec< unsigned int,2 >::value_type arg2 ;
+  VecMat::Vec< unsigned int,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   unsigned int val2 ;
@@ -11252,19 +11072,19 @@ SWIGINTERN PyObject *_wrap_Vec_2u___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self)
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___mul__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___mul__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___mul__" "', argument " "1"" of type '" "VecMat::Vec< unsigned int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp1);
   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2u___mul__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2u___mul__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 >::value_type""'");
   } 
-  arg2 = static_cast< VecMat::Vec<unsigned int,2 >::value_type >(val2);
+  arg2 = static_cast< VecMat::Vec< unsigned int,2 >::value_type >(val2);
   {
     try {
-      result = ((VecMat::Vec<unsigned int,2 > const *)arg1)->operator *(arg2);
+      result = ((VecMat::Vec< unsigned int,2 > const *)arg1)->operator *(arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11273,7 +11093,7 @@ SWIGINTERN PyObject *_wrap_Vec_2u___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self)
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<unsigned int,2 >(static_cast< const VecMat::Vec<unsigned int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< unsigned int,2 >(static_cast< const VecMat::Vec< unsigned int,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -11282,9 +11102,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2u___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
-  VecMat::Vec<unsigned int,2 >::value_type arg2 ;
-  VecMat::Vec<unsigned int,2 > result;
+  VecMat::Vec< unsigned int,2 > *arg1 = (VecMat::Vec< unsigned int,2 > *) 0 ;
+  VecMat::Vec< unsigned int,2 >::value_type arg2 ;
+  VecMat::Vec< unsigned int,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   unsigned int val2 ;
@@ -11293,19 +11113,19 @@ SWIGINTERN PyObject *_wrap_Vec_2u___div__(PyObject *SWIGUNUSEDPARM(self), PyObje
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___div__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___div__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___div__" "', argument " "1"" of type '" "VecMat::Vec< unsigned int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp1);
   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2u___div__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2u___div__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 >::value_type""'");
   } 
-  arg2 = static_cast< VecMat::Vec<unsigned int,2 >::value_type >(val2);
+  arg2 = static_cast< VecMat::Vec< unsigned int,2 >::value_type >(val2);
   {
     try {
-      result = ((VecMat::Vec<unsigned int,2 > const *)arg1)->operator /(arg2);
+      result = ((VecMat::Vec< unsigned int,2 > const *)arg1)->operator /(arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11314,7 +11134,7 @@ SWIGINTERN PyObject *_wrap_Vec_2u___div__(PyObject *SWIGUNUSEDPARM(self), PyObje
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<unsigned int,2 >(static_cast< const VecMat::Vec<unsigned int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< unsigned int,2 >(static_cast< const VecMat::Vec< unsigned int,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -11323,9 +11143,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2u___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
-  VecMat::Vec<unsigned int,2 > *arg2 = 0 ;
-  VecMat::Vec<unsigned int,2 >::value_type result;
+  VecMat::Vec< unsigned int,2 > *arg1 = (VecMat::Vec< unsigned int,2 > *) 0 ;
+  VecMat::Vec< unsigned int,2 > *arg2 = 0 ;
+  VecMat::Vec< unsigned int,2 >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -11334,22 +11154,22 @@ SWIGINTERN PyObject *_wrap_Vec_2u___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self)
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___mul__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___mul__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___mul__" "', argument " "1"" of type '" "VecMat::Vec< unsigned int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___mul__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___mul__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___mul__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___mul__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp2);
   {
     try {
-      result = (VecMat::Vec<unsigned int,2 >::value_type)((VecMat::Vec<unsigned int,2 > const *)arg1)->operator *((VecMat::Vec<unsigned int,2 > const &)*arg2);
+      result = (VecMat::Vec< unsigned int,2 >::value_type)((VecMat::Vec< unsigned int,2 > const *)arg1)->operator *((VecMat::Vec< unsigned int,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11371,17 +11191,17 @@ SWIGINTERN PyObject *_wrap_Vec_2u___mul__(PyObject *self, PyObject *args) {
   int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
+  argc = (int)PyObject_Length(args);
   for (ii = 0; (ii < argc) && (ii < 2); 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_VecMat__VecTunsigned_int_2_t, 0);
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
-      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0);
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0);
       _v = SWIG_CheckState(res);
       if (_v) {
         return _wrap_Vec_2u___mul____SWIG_1(self, args);
@@ -11391,7 +11211,7 @@ SWIGINTERN PyObject *_wrap_Vec_2u___mul__(PyObject *self, PyObject *args) {
   if (argc == 2) {
     int _v;
     void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0);
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -11412,8 +11232,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2u___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
-  VecMat::Vec<unsigned int,2 > *arg2 = 0 ;
+  VecMat::Vec< unsigned int,2 > *arg1 = (VecMat::Vec< unsigned int,2 > *) 0 ;
+  VecMat::Vec< unsigned int,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -11423,22 +11243,22 @@ SWIGINTERN PyObject *_wrap_Vec_2u___eq__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___eq__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___eq__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___eq__" "', argument " "1"" of type '" "VecMat::Vec< unsigned int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___eq__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___eq__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___eq__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___eq__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<unsigned int,2 > const *)arg1)->operator ==((VecMat::Vec<unsigned int,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< unsigned int,2 > const *)arg1)->operator ==((VecMat::Vec< unsigned int,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11456,8 +11276,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2u___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
-  VecMat::Vec<unsigned int,2 > *arg2 = 0 ;
+  VecMat::Vec< unsigned int,2 > *arg1 = (VecMat::Vec< unsigned int,2 > *) 0 ;
+  VecMat::Vec< unsigned int,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -11467,22 +11287,22 @@ SWIGINTERN PyObject *_wrap_Vec_2u___ne__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___ne__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___ne__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___ne__" "', argument " "1"" of type '" "VecMat::Vec< unsigned int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___ne__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___ne__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___ne__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___ne__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<unsigned int,2 > const *)arg1)->operator !=((VecMat::Vec<unsigned int,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< unsigned int,2 > const *)arg1)->operator !=((VecMat::Vec< unsigned int,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11500,8 +11320,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2u___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
-  VecMat::Vec<unsigned int,2 > *arg2 = 0 ;
+  VecMat::Vec< unsigned int,2 > *arg1 = (VecMat::Vec< unsigned int,2 > *) 0 ;
+  VecMat::Vec< unsigned int,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -11511,22 +11331,22 @@ SWIGINTERN PyObject *_wrap_Vec_2u___lt__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___lt__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___lt__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___lt__" "', argument " "1"" of type '" "VecMat::Vec< unsigned int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___lt__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___lt__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___lt__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___lt__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<unsigned int,2 > const *)arg1)->operator <((VecMat::Vec<unsigned int,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< unsigned int,2 > const *)arg1)->operator <((VecMat::Vec< unsigned int,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11544,8 +11364,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2u___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<unsigned int,2 > *arg1 = (VecMat::Vec<unsigned int,2 > *) 0 ;
-  VecMat::Vec<unsigned int,2 > *arg2 = 0 ;
+  VecMat::Vec< unsigned int,2 > *arg1 = (VecMat::Vec< unsigned int,2 > *) 0 ;
+  VecMat::Vec< unsigned int,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -11555,22 +11375,22 @@ SWIGINTERN PyObject *_wrap_Vec_2u___gt__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2u___gt__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___gt__" "', argument " "1"" of type '" "VecMat::Vec<unsigned int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2u___gt__" "', argument " "1"" of type '" "VecMat::Vec< unsigned int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTunsigned_int_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___gt__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2u___gt__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___gt__" "', argument " "2"" of type '" "VecMat::Vec<unsigned int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2u___gt__" "', argument " "2"" of type '" "VecMat::Vec< unsigned int,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<unsigned int,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< unsigned int,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<unsigned int,2 > const *)arg1)->operator >((VecMat::Vec<unsigned int,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< unsigned int,2 > const *)arg1)->operator >((VecMat::Vec< unsigned int,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11588,19 +11408,19 @@ fail:
 
 SWIGINTERN PyObject *Vec_2u_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecTunsigned_int_2_t, SWIG_NewClientData(obj));
+  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecT_unsigned_int_2_t, SWIG_NewClientData(obj));
   return SWIG_Py_Void();
 }
 
 SWIGINTERN PyObject *_wrap_new_Vec_2i(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *result = 0 ;
+  VecMat::Vec< int,2 > *result = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)":new_Vec_2i")) SWIG_fail;
   {
     try {
-      result = (VecMat::Vec<int,2 > *)new VecMat::Vec<int,2 >();
+      result = (VecMat::Vec< int,2 > *)new VecMat::Vec< int,2 >();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11609,7 +11429,7 @@ SWIGINTERN PyObject *_wrap_new_Vec_2i(PyObject *SWIGUNUSEDPARM(self), PyObject *
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTint_2_t, SWIG_POINTER_NEW |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecT_int_2_t, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -11618,17 +11438,17 @@ fail:
 
 SWIGINTERN PyObject *_wrap_delete_Vec_2i(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
+  VecMat::Vec< int,2 > *arg1 = (VecMat::Vec< int,2 > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec_2i",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, SWIG_POINTER_DISOWN |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_int_2_t, SWIG_POINTER_DISOWN |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_2i" "', argument " "1"" of type '" "VecMat::Vec<int,2 > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_2i" "', argument " "1"" of type '" "VecMat::Vec< int,2 > *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp1);
   {
     try {
       delete arg1;
@@ -11655,7 +11475,7 @@ SWIGINTERN PyObject *_wrap_Vec_2i_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *
   if (!PyArg_ParseTuple(args,(char *)":Vec_2i_dim")) SWIG_fail;
   {
     try {
-      result = (unsigned int)VecMat::Vec<int,2 >::SWIGTEMPLATEDISAMBIGUATOR dim();
+      result = (unsigned int)VecMat::Vec< int,2 >::SWIGTEMPLATEDISAMBIGUATOR dim();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11673,21 +11493,21 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2i_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
-  VecMat::Vec<int,2 >::value_type result;
+  VecMat::Vec< int,2 > *arg1 = (VecMat::Vec< int,2 > *) 0 ;
+  VecMat::Vec< int,2 >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2i_norm",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i_norm" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i_norm" "', argument " "1"" of type '" "VecMat::Vec< int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp1);
   {
     try {
-      result = (VecMat::Vec<int,2 >::value_type)((VecMat::Vec<int,2 > const *)arg1)->norm();
+      result = (VecMat::Vec< int,2 >::value_type)((VecMat::Vec< int,2 > const *)arg1)->norm();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11705,21 +11525,21 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2i_squareNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
-  VecMat::Vec<int,2 >::value_type result;
+  VecMat::Vec< int,2 > *arg1 = (VecMat::Vec< int,2 > *) 0 ;
+  VecMat::Vec< int,2 >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2i_squareNorm",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i_squareNorm" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i_squareNorm" "', argument " "1"" of type '" "VecMat::Vec< int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp1);
   {
     try {
-      result = (VecMat::Vec<int,2 >::value_type)((VecMat::Vec<int,2 > const *)arg1)->squareNorm();
+      result = (VecMat::Vec< int,2 >::value_type)((VecMat::Vec< int,2 > const *)arg1)->squareNorm();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11737,23 +11557,23 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2i_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
-  VecMat::Vec<int,2 > *result = 0 ;
+  VecMat::Vec< int,2 > *arg1 = (VecMat::Vec< int,2 > *) 0 ;
+  VecMat::Vec< int,2 > *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2i_normalize",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i_normalize" "', argument " "1"" of type '" "VecMat::Vec<int,2 > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i_normalize" "', argument " "1"" of type '" "VecMat::Vec< int,2 > *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp1);
   {
     try {
       {
-        VecMat::Vec<int,2 > &_result_ref = (arg1)->normalize();
-        result = (VecMat::Vec<int,2 > *) &_result_ref;
+        VecMat::Vec< int,2 > &_result_ref = (arg1)->normalize();
+        result = (VecMat::Vec< int,2 > *) &_result_ref;
       }
     }
     //    catch (Swig::DirectorTypeMismatch&) {
@@ -11763,7 +11583,7 @@ SWIGINTERN PyObject *_wrap_Vec_2i_normalize(PyObject *SWIGUNUSEDPARM(self), PyOb
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -11772,23 +11592,23 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2i_normalizeSafe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
-  VecMat::Vec<int,2 > *result = 0 ;
+  VecMat::Vec< int,2 > *arg1 = (VecMat::Vec< int,2 > *) 0 ;
+  VecMat::Vec< int,2 > *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2i_normalizeSafe",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec<int,2 > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec< int,2 > *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp1);
   {
     try {
       {
-        VecMat::Vec<int,2 > &_result_ref = (arg1)->normalizeSafe();
-        result = (VecMat::Vec<int,2 > *) &_result_ref;
+        VecMat::Vec< int,2 > &_result_ref = (arg1)->normalizeSafe();
+        result = (VecMat::Vec< int,2 > *) &_result_ref;
       }
     }
     //    catch (Swig::DirectorTypeMismatch&) {
@@ -11798,7 +11618,7 @@ SWIGINTERN PyObject *_wrap_Vec_2i_normalizeSafe(PyObject *SWIGUNUSEDPARM(self),
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -11807,9 +11627,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2i___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
-  VecMat::Vec<int,2 > *arg2 = 0 ;
-  VecMat::Vec<int,2 > result;
+  VecMat::Vec< int,2 > *arg1 = (VecMat::Vec< int,2 > *) 0 ;
+  VecMat::Vec< int,2 > *arg2 = 0 ;
+  VecMat::Vec< int,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -11818,22 +11638,22 @@ SWIGINTERN PyObject *_wrap_Vec_2i___add__(PyObject *SWIGUNUSEDPARM(self), PyObje
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___add__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___add__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___add__" "', argument " "1"" of type '" "VecMat::Vec< int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_int_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___add__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___add__" "', argument " "2"" of type '" "VecMat::Vec< int,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___add__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___add__" "', argument " "2"" of type '" "VecMat::Vec< int,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp2);
   {
     try {
-      result = ((VecMat::Vec<int,2 > const *)arg1)->operator +((VecMat::Vec<int,2 > const &)*arg2);
+      result = ((VecMat::Vec< int,2 > const *)arg1)->operator +((VecMat::Vec< int,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11842,7 +11662,7 @@ SWIGINTERN PyObject *_wrap_Vec_2i___add__(PyObject *SWIGUNUSEDPARM(self), PyObje
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<int,2 >(static_cast< const VecMat::Vec<int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTint_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< int,2 >(static_cast< const VecMat::Vec< int,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_int_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -11851,9 +11671,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2i___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
-  VecMat::Vec<int,2 > *arg2 = 0 ;
-  VecMat::Vec<int,2 > result;
+  VecMat::Vec< int,2 > *arg1 = (VecMat::Vec< int,2 > *) 0 ;
+  VecMat::Vec< int,2 > *arg2 = 0 ;
+  VecMat::Vec< int,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -11862,22 +11682,22 @@ SWIGINTERN PyObject *_wrap_Vec_2i___sub__(PyObject *SWIGUNUSEDPARM(self), PyObje
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___sub__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___sub__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___sub__" "', argument " "1"" of type '" "VecMat::Vec< int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_int_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___sub__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___sub__" "', argument " "2"" of type '" "VecMat::Vec< int,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___sub__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___sub__" "', argument " "2"" of type '" "VecMat::Vec< int,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp2);
   {
     try {
-      result = ((VecMat::Vec<int,2 > const *)arg1)->operator -((VecMat::Vec<int,2 > const &)*arg2);
+      result = ((VecMat::Vec< int,2 > const *)arg1)->operator -((VecMat::Vec< int,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11886,7 +11706,7 @@ SWIGINTERN PyObject *_wrap_Vec_2i___sub__(PyObject *SWIGUNUSEDPARM(self), PyObje
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<int,2 >(static_cast< const VecMat::Vec<int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTint_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< int,2 >(static_cast< const VecMat::Vec< int,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_int_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -11895,9 +11715,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2i___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
-  VecMat::Vec<int,2 >::value_type arg2 ;
-  VecMat::Vec<int,2 > result;
+  VecMat::Vec< int,2 > *arg1 = (VecMat::Vec< int,2 > *) 0 ;
+  VecMat::Vec< int,2 >::value_type arg2 ;
+  VecMat::Vec< int,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   int val2 ;
@@ -11906,19 +11726,19 @@ SWIGINTERN PyObject *_wrap_Vec_2i___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self)
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___mul__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___mul__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___mul__" "', argument " "1"" of type '" "VecMat::Vec< int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp1);
   ecode2 = SWIG_AsVal_int(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2i___mul__" "', argument " "2"" of type '" "VecMat::Vec<int,2 >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2i___mul__" "', argument " "2"" of type '" "VecMat::Vec< int,2 >::value_type""'");
   } 
-  arg2 = static_cast< VecMat::Vec<int,2 >::value_type >(val2);
+  arg2 = static_cast< VecMat::Vec< int,2 >::value_type >(val2);
   {
     try {
-      result = ((VecMat::Vec<int,2 > const *)arg1)->operator *(arg2);
+      result = ((VecMat::Vec< int,2 > const *)arg1)->operator *(arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11927,7 +11747,7 @@ SWIGINTERN PyObject *_wrap_Vec_2i___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self)
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<int,2 >(static_cast< const VecMat::Vec<int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTint_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< int,2 >(static_cast< const VecMat::Vec< int,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_int_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -11936,9 +11756,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2i___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
-  VecMat::Vec<int,2 >::value_type arg2 ;
-  VecMat::Vec<int,2 > result;
+  VecMat::Vec< int,2 > *arg1 = (VecMat::Vec< int,2 > *) 0 ;
+  VecMat::Vec< int,2 >::value_type arg2 ;
+  VecMat::Vec< int,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   int val2 ;
@@ -11947,19 +11767,19 @@ SWIGINTERN PyObject *_wrap_Vec_2i___div__(PyObject *SWIGUNUSEDPARM(self), PyObje
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___div__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___div__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___div__" "', argument " "1"" of type '" "VecMat::Vec< int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp1);
   ecode2 = SWIG_AsVal_int(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2i___div__" "', argument " "2"" of type '" "VecMat::Vec<int,2 >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2i___div__" "', argument " "2"" of type '" "VecMat::Vec< int,2 >::value_type""'");
   } 
-  arg2 = static_cast< VecMat::Vec<int,2 >::value_type >(val2);
+  arg2 = static_cast< VecMat::Vec< int,2 >::value_type >(val2);
   {
     try {
-      result = ((VecMat::Vec<int,2 > const *)arg1)->operator /(arg2);
+      result = ((VecMat::Vec< int,2 > const *)arg1)->operator /(arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -11968,7 +11788,7 @@ SWIGINTERN PyObject *_wrap_Vec_2i___div__(PyObject *SWIGUNUSEDPARM(self), PyObje
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<int,2 >(static_cast< const VecMat::Vec<int,2 >& >(result))), SWIGTYPE_p_VecMat__VecTint_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< int,2 >(static_cast< const VecMat::Vec< int,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_int_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -11977,9 +11797,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2i___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
-  VecMat::Vec<int,2 > *arg2 = 0 ;
-  VecMat::Vec<int,2 >::value_type result;
+  VecMat::Vec< int,2 > *arg1 = (VecMat::Vec< int,2 > *) 0 ;
+  VecMat::Vec< int,2 > *arg2 = 0 ;
+  VecMat::Vec< int,2 >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -11988,22 +11808,22 @@ SWIGINTERN PyObject *_wrap_Vec_2i___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self)
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___mul__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___mul__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___mul__" "', argument " "1"" of type '" "VecMat::Vec< int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_int_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___mul__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___mul__" "', argument " "2"" of type '" "VecMat::Vec< int,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___mul__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___mul__" "', argument " "2"" of type '" "VecMat::Vec< int,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp2);
   {
     try {
-      result = (VecMat::Vec<int,2 >::value_type)((VecMat::Vec<int,2 > const *)arg1)->operator *((VecMat::Vec<int,2 > const &)*arg2);
+      result = (VecMat::Vec< int,2 >::value_type)((VecMat::Vec< int,2 > const *)arg1)->operator *((VecMat::Vec< int,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12025,17 +11845,17 @@ SWIGINTERN PyObject *_wrap_Vec_2i___mul__(PyObject *self, PyObject *args) {
   int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
+  argc = (int)PyObject_Length(args);
   for (ii = 0; (ii < argc) && (ii < 2); 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_VecMat__VecTint_2_t, 0);
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecT_int_2_t, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
-      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecTint_2_t, 0);
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecT_int_2_t, 0);
       _v = SWIG_CheckState(res);
       if (_v) {
         return _wrap_Vec_2i___mul____SWIG_1(self, args);
@@ -12045,7 +11865,7 @@ SWIGINTERN PyObject *_wrap_Vec_2i___mul__(PyObject *self, PyObject *args) {
   if (argc == 2) {
     int _v;
     void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTint_2_t, 0);
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecT_int_2_t, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -12066,8 +11886,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2i___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
-  VecMat::Vec<int,2 > *arg2 = 0 ;
+  VecMat::Vec< int,2 > *arg1 = (VecMat::Vec< int,2 > *) 0 ;
+  VecMat::Vec< int,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -12077,22 +11897,22 @@ SWIGINTERN PyObject *_wrap_Vec_2i___eq__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___eq__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___eq__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___eq__" "', argument " "1"" of type '" "VecMat::Vec< int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_int_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___eq__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___eq__" "', argument " "2"" of type '" "VecMat::Vec< int,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___eq__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___eq__" "', argument " "2"" of type '" "VecMat::Vec< int,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<int,2 > const *)arg1)->operator ==((VecMat::Vec<int,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< int,2 > const *)arg1)->operator ==((VecMat::Vec< int,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12110,8 +11930,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2i___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
-  VecMat::Vec<int,2 > *arg2 = 0 ;
+  VecMat::Vec< int,2 > *arg1 = (VecMat::Vec< int,2 > *) 0 ;
+  VecMat::Vec< int,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -12121,22 +11941,22 @@ SWIGINTERN PyObject *_wrap_Vec_2i___ne__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___ne__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___ne__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___ne__" "', argument " "1"" of type '" "VecMat::Vec< int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_int_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___ne__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___ne__" "', argument " "2"" of type '" "VecMat::Vec< int,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___ne__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___ne__" "', argument " "2"" of type '" "VecMat::Vec< int,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<int,2 > const *)arg1)->operator !=((VecMat::Vec<int,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< int,2 > const *)arg1)->operator !=((VecMat::Vec< int,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12154,8 +11974,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2i___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
-  VecMat::Vec<int,2 > *arg2 = 0 ;
+  VecMat::Vec< int,2 > *arg1 = (VecMat::Vec< int,2 > *) 0 ;
+  VecMat::Vec< int,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -12165,22 +11985,22 @@ SWIGINTERN PyObject *_wrap_Vec_2i___lt__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___lt__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___lt__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___lt__" "', argument " "1"" of type '" "VecMat::Vec< int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_int_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___lt__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___lt__" "', argument " "2"" of type '" "VecMat::Vec< int,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___lt__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___lt__" "', argument " "2"" of type '" "VecMat::Vec< int,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<int,2 > const *)arg1)->operator <((VecMat::Vec<int,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< int,2 > const *)arg1)->operator <((VecMat::Vec< int,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12198,8 +12018,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2i___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<int,2 > *arg1 = (VecMat::Vec<int,2 > *) 0 ;
-  VecMat::Vec<int,2 > *arg2 = 0 ;
+  VecMat::Vec< int,2 > *arg1 = (VecMat::Vec< int,2 > *) 0 ;
+  VecMat::Vec< int,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -12209,22 +12029,22 @@ SWIGINTERN PyObject *_wrap_Vec_2i___gt__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2i___gt__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTint_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_int_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___gt__" "', argument " "1"" of type '" "VecMat::Vec<int,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2i___gt__" "', argument " "1"" of type '" "VecMat::Vec< int,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTint_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_int_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___gt__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2i___gt__" "', argument " "2"" of type '" "VecMat::Vec< int,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___gt__" "', argument " "2"" of type '" "VecMat::Vec<int,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2i___gt__" "', argument " "2"" of type '" "VecMat::Vec< int,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<int,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< int,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<int,2 > const *)arg1)->operator >((VecMat::Vec<int,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< int,2 > const *)arg1)->operator >((VecMat::Vec< int,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12242,19 +12062,19 @@ fail:
 
 SWIGINTERN PyObject *Vec_2i_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecTint_2_t, SWIG_NewClientData(obj));
+  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecT_int_2_t, SWIG_NewClientData(obj));
   return SWIG_Py_Void();
 }
 
 SWIGINTERN PyObject *_wrap_new_Vec_2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *result = 0 ;
+  VecMat::Vec< double,2 > *result = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)":new_Vec_2d")) SWIG_fail;
   {
     try {
-      result = (VecMat::Vec<double,2 > *)new VecMat::Vec<double,2 >();
+      result = (VecMat::Vec< double,2 > *)new VecMat::Vec< double,2 >();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12263,7 +12083,7 @@ SWIGINTERN PyObject *_wrap_new_Vec_2d(PyObject *SWIGUNUSEDPARM(self), PyObject *
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTdouble_2_t, SWIG_POINTER_NEW |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecT_double_2_t, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -12272,17 +12092,17 @@ fail:
 
 SWIGINTERN PyObject *_wrap_delete_Vec_2d(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
+  VecMat::Vec< double,2 > *arg1 = (VecMat::Vec< double,2 > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec_2d",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, SWIG_POINTER_DISOWN |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_double_2_t, SWIG_POINTER_DISOWN |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_2d" "', argument " "1"" of type '" "VecMat::Vec<double,2 > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_2d" "', argument " "1"" of type '" "VecMat::Vec< double,2 > *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp1);
   {
     try {
       delete arg1;
@@ -12309,7 +12129,7 @@ SWIGINTERN PyObject *_wrap_Vec_2d_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *
   if (!PyArg_ParseTuple(args,(char *)":Vec_2d_dim")) SWIG_fail;
   {
     try {
-      result = (unsigned int)VecMat::Vec<double,2 >::SWIGTEMPLATEDISAMBIGUATOR dim();
+      result = (unsigned int)VecMat::Vec< double,2 >::SWIGTEMPLATEDISAMBIGUATOR dim();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12327,21 +12147,21 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2d_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
-  VecMat::Vec<double,2 >::value_type result;
+  VecMat::Vec< double,2 > *arg1 = (VecMat::Vec< double,2 > *) 0 ;
+  VecMat::Vec< double,2 >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2d_norm",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d_norm" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d_norm" "', argument " "1"" of type '" "VecMat::Vec< double,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp1);
   {
     try {
-      result = (VecMat::Vec<double,2 >::value_type)((VecMat::Vec<double,2 > const *)arg1)->norm();
+      result = (VecMat::Vec< double,2 >::value_type)((VecMat::Vec< double,2 > const *)arg1)->norm();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12359,21 +12179,21 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2d_squareNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
-  VecMat::Vec<double,2 >::value_type result;
+  VecMat::Vec< double,2 > *arg1 = (VecMat::Vec< double,2 > *) 0 ;
+  VecMat::Vec< double,2 >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2d_squareNorm",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d_squareNorm" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d_squareNorm" "', argument " "1"" of type '" "VecMat::Vec< double,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp1);
   {
     try {
-      result = (VecMat::Vec<double,2 >::value_type)((VecMat::Vec<double,2 > const *)arg1)->squareNorm();
+      result = (VecMat::Vec< double,2 >::value_type)((VecMat::Vec< double,2 > const *)arg1)->squareNorm();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12391,23 +12211,23 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2d_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
-  VecMat::Vec<double,2 > *result = 0 ;
+  VecMat::Vec< double,2 > *arg1 = (VecMat::Vec< double,2 > *) 0 ;
+  VecMat::Vec< double,2 > *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2d_normalize",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d_normalize" "', argument " "1"" of type '" "VecMat::Vec<double,2 > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d_normalize" "', argument " "1"" of type '" "VecMat::Vec< double,2 > *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp1);
   {
     try {
       {
-        VecMat::Vec<double,2 > &_result_ref = (arg1)->normalize();
-        result = (VecMat::Vec<double,2 > *) &_result_ref;
+        VecMat::Vec< double,2 > &_result_ref = (arg1)->normalize();
+        result = (VecMat::Vec< double,2 > *) &_result_ref;
       }
     }
     //    catch (Swig::DirectorTypeMismatch&) {
@@ -12417,7 +12237,7 @@ SWIGINTERN PyObject *_wrap_Vec_2d_normalize(PyObject *SWIGUNUSEDPARM(self), PyOb
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -12426,23 +12246,23 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2d_normalizeSafe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
-  VecMat::Vec<double,2 > *result = 0 ;
+  VecMat::Vec< double,2 > *arg1 = (VecMat::Vec< double,2 > *) 0 ;
+  VecMat::Vec< double,2 > *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2d_normalizeSafe",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec<double,2 > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec< double,2 > *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp1);
   {
     try {
       {
-        VecMat::Vec<double,2 > &_result_ref = (arg1)->normalizeSafe();
-        result = (VecMat::Vec<double,2 > *) &_result_ref;
+        VecMat::Vec< double,2 > &_result_ref = (arg1)->normalizeSafe();
+        result = (VecMat::Vec< double,2 > *) &_result_ref;
       }
     }
     //    catch (Swig::DirectorTypeMismatch&) {
@@ -12452,7 +12272,7 @@ SWIGINTERN PyObject *_wrap_Vec_2d_normalizeSafe(PyObject *SWIGUNUSEDPARM(self),
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -12461,9 +12281,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2d___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
-  VecMat::Vec<double,2 > *arg2 = 0 ;
-  VecMat::Vec<double,2 > result;
+  VecMat::Vec< double,2 > *arg1 = (VecMat::Vec< double,2 > *) 0 ;
+  VecMat::Vec< double,2 > *arg2 = 0 ;
+  VecMat::Vec< double,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -12472,22 +12292,22 @@ SWIGINTERN PyObject *_wrap_Vec_2d___add__(PyObject *SWIGUNUSEDPARM(self), PyObje
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___add__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___add__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___add__" "', argument " "1"" of type '" "VecMat::Vec< double,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_double_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___add__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___add__" "', argument " "2"" of type '" "VecMat::Vec< double,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___add__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___add__" "', argument " "2"" of type '" "VecMat::Vec< double,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp2);
   {
     try {
-      result = ((VecMat::Vec<double,2 > const *)arg1)->operator +((VecMat::Vec<double,2 > const &)*arg2);
+      result = ((VecMat::Vec< double,2 > const *)arg1)->operator +((VecMat::Vec< double,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12496,7 +12316,7 @@ SWIGINTERN PyObject *_wrap_Vec_2d___add__(PyObject *SWIGUNUSEDPARM(self), PyObje
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<double,2 >(static_cast< const VecMat::Vec<double,2 >& >(result))), SWIGTYPE_p_VecMat__VecTdouble_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< double,2 >(static_cast< const VecMat::Vec< double,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_double_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -12505,9 +12325,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2d___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
-  VecMat::Vec<double,2 > *arg2 = 0 ;
-  VecMat::Vec<double,2 > result;
+  VecMat::Vec< double,2 > *arg1 = (VecMat::Vec< double,2 > *) 0 ;
+  VecMat::Vec< double,2 > *arg2 = 0 ;
+  VecMat::Vec< double,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -12516,22 +12336,22 @@ SWIGINTERN PyObject *_wrap_Vec_2d___sub__(PyObject *SWIGUNUSEDPARM(self), PyObje
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___sub__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___sub__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___sub__" "', argument " "1"" of type '" "VecMat::Vec< double,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_double_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___sub__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___sub__" "', argument " "2"" of type '" "VecMat::Vec< double,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___sub__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___sub__" "', argument " "2"" of type '" "VecMat::Vec< double,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp2);
   {
     try {
-      result = ((VecMat::Vec<double,2 > const *)arg1)->operator -((VecMat::Vec<double,2 > const &)*arg2);
+      result = ((VecMat::Vec< double,2 > const *)arg1)->operator -((VecMat::Vec< double,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12540,7 +12360,7 @@ SWIGINTERN PyObject *_wrap_Vec_2d___sub__(PyObject *SWIGUNUSEDPARM(self), PyObje
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<double,2 >(static_cast< const VecMat::Vec<double,2 >& >(result))), SWIGTYPE_p_VecMat__VecTdouble_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< double,2 >(static_cast< const VecMat::Vec< double,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_double_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -12549,9 +12369,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2d___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
-  VecMat::Vec<double,2 >::value_type arg2 ;
-  VecMat::Vec<double,2 > result;
+  VecMat::Vec< double,2 > *arg1 = (VecMat::Vec< double,2 > *) 0 ;
+  VecMat::Vec< double,2 >::value_type arg2 ;
+  VecMat::Vec< double,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   double val2 ;
@@ -12560,19 +12380,19 @@ SWIGINTERN PyObject *_wrap_Vec_2d___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self)
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___mul__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___mul__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___mul__" "', argument " "1"" of type '" "VecMat::Vec< double,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp1);
   ecode2 = SWIG_AsVal_double(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2d___mul__" "', argument " "2"" of type '" "VecMat::Vec<double,2 >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2d___mul__" "', argument " "2"" of type '" "VecMat::Vec< double,2 >::value_type""'");
   } 
-  arg2 = static_cast< VecMat::Vec<double,2 >::value_type >(val2);
+  arg2 = static_cast< VecMat::Vec< double,2 >::value_type >(val2);
   {
     try {
-      result = ((VecMat::Vec<double,2 > const *)arg1)->operator *(arg2);
+      result = ((VecMat::Vec< double,2 > const *)arg1)->operator *(arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12581,7 +12401,7 @@ SWIGINTERN PyObject *_wrap_Vec_2d___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self)
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<double,2 >(static_cast< const VecMat::Vec<double,2 >& >(result))), SWIGTYPE_p_VecMat__VecTdouble_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< double,2 >(static_cast< const VecMat::Vec< double,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_double_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -12590,9 +12410,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2d___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
-  VecMat::Vec<double,2 >::value_type arg2 ;
-  VecMat::Vec<double,2 > result;
+  VecMat::Vec< double,2 > *arg1 = (VecMat::Vec< double,2 > *) 0 ;
+  VecMat::Vec< double,2 >::value_type arg2 ;
+  VecMat::Vec< double,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   double val2 ;
@@ -12601,19 +12421,19 @@ SWIGINTERN PyObject *_wrap_Vec_2d___div__(PyObject *SWIGUNUSEDPARM(self), PyObje
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___div__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___div__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___div__" "', argument " "1"" of type '" "VecMat::Vec< double,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp1);
   ecode2 = SWIG_AsVal_double(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2d___div__" "', argument " "2"" of type '" "VecMat::Vec<double,2 >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2d___div__" "', argument " "2"" of type '" "VecMat::Vec< double,2 >::value_type""'");
   } 
-  arg2 = static_cast< VecMat::Vec<double,2 >::value_type >(val2);
+  arg2 = static_cast< VecMat::Vec< double,2 >::value_type >(val2);
   {
     try {
-      result = ((VecMat::Vec<double,2 > const *)arg1)->operator /(arg2);
+      result = ((VecMat::Vec< double,2 > const *)arg1)->operator /(arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12622,7 +12442,7 @@ SWIGINTERN PyObject *_wrap_Vec_2d___div__(PyObject *SWIGUNUSEDPARM(self), PyObje
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<double,2 >(static_cast< const VecMat::Vec<double,2 >& >(result))), SWIGTYPE_p_VecMat__VecTdouble_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< double,2 >(static_cast< const VecMat::Vec< double,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_double_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -12631,9 +12451,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2d___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
-  VecMat::Vec<double,2 > *arg2 = 0 ;
-  VecMat::Vec<double,2 >::value_type result;
+  VecMat::Vec< double,2 > *arg1 = (VecMat::Vec< double,2 > *) 0 ;
+  VecMat::Vec< double,2 > *arg2 = 0 ;
+  VecMat::Vec< double,2 >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -12642,22 +12462,22 @@ SWIGINTERN PyObject *_wrap_Vec_2d___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self)
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___mul__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___mul__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___mul__" "', argument " "1"" of type '" "VecMat::Vec< double,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_double_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___mul__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___mul__" "', argument " "2"" of type '" "VecMat::Vec< double,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___mul__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___mul__" "', argument " "2"" of type '" "VecMat::Vec< double,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp2);
   {
     try {
-      result = (VecMat::Vec<double,2 >::value_type)((VecMat::Vec<double,2 > const *)arg1)->operator *((VecMat::Vec<double,2 > const &)*arg2);
+      result = (VecMat::Vec< double,2 >::value_type)((VecMat::Vec< double,2 > const *)arg1)->operator *((VecMat::Vec< double,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12679,17 +12499,17 @@ SWIGINTERN PyObject *_wrap_Vec_2d___mul__(PyObject *self, PyObject *args) {
   int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
+  argc = (int)PyObject_Length(args);
   for (ii = 0; (ii < argc) && (ii < 2); 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_VecMat__VecTdouble_2_t, 0);
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecT_double_2_t, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
-      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecTdouble_2_t, 0);
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecT_double_2_t, 0);
       _v = SWIG_CheckState(res);
       if (_v) {
         return _wrap_Vec_2d___mul____SWIG_1(self, args);
@@ -12699,7 +12519,7 @@ SWIGINTERN PyObject *_wrap_Vec_2d___mul__(PyObject *self, PyObject *args) {
   if (argc == 2) {
     int _v;
     void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTdouble_2_t, 0);
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecT_double_2_t, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -12720,8 +12540,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2d___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
-  VecMat::Vec<double,2 > *arg2 = 0 ;
+  VecMat::Vec< double,2 > *arg1 = (VecMat::Vec< double,2 > *) 0 ;
+  VecMat::Vec< double,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -12731,22 +12551,22 @@ SWIGINTERN PyObject *_wrap_Vec_2d___eq__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___eq__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___eq__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___eq__" "', argument " "1"" of type '" "VecMat::Vec< double,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_double_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___eq__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___eq__" "', argument " "2"" of type '" "VecMat::Vec< double,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___eq__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___eq__" "', argument " "2"" of type '" "VecMat::Vec< double,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<double,2 > const *)arg1)->operator ==((VecMat::Vec<double,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< double,2 > const *)arg1)->operator ==((VecMat::Vec< double,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12764,8 +12584,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2d___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
-  VecMat::Vec<double,2 > *arg2 = 0 ;
+  VecMat::Vec< double,2 > *arg1 = (VecMat::Vec< double,2 > *) 0 ;
+  VecMat::Vec< double,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -12775,22 +12595,22 @@ SWIGINTERN PyObject *_wrap_Vec_2d___ne__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___ne__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___ne__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___ne__" "', argument " "1"" of type '" "VecMat::Vec< double,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_double_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___ne__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___ne__" "', argument " "2"" of type '" "VecMat::Vec< double,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___ne__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___ne__" "', argument " "2"" of type '" "VecMat::Vec< double,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<double,2 > const *)arg1)->operator !=((VecMat::Vec<double,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< double,2 > const *)arg1)->operator !=((VecMat::Vec< double,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12808,8 +12628,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2d___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
-  VecMat::Vec<double,2 > *arg2 = 0 ;
+  VecMat::Vec< double,2 > *arg1 = (VecMat::Vec< double,2 > *) 0 ;
+  VecMat::Vec< double,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -12819,22 +12639,22 @@ SWIGINTERN PyObject *_wrap_Vec_2d___lt__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___lt__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___lt__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___lt__" "', argument " "1"" of type '" "VecMat::Vec< double,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_double_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___lt__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___lt__" "', argument " "2"" of type '" "VecMat::Vec< double,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___lt__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___lt__" "', argument " "2"" of type '" "VecMat::Vec< double,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<double,2 > const *)arg1)->operator <((VecMat::Vec<double,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< double,2 > const *)arg1)->operator <((VecMat::Vec< double,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12852,8 +12672,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2d___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<double,2 > *arg1 = (VecMat::Vec<double,2 > *) 0 ;
-  VecMat::Vec<double,2 > *arg2 = 0 ;
+  VecMat::Vec< double,2 > *arg1 = (VecMat::Vec< double,2 > *) 0 ;
+  VecMat::Vec< double,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -12863,22 +12683,22 @@ SWIGINTERN PyObject *_wrap_Vec_2d___gt__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2d___gt__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTdouble_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_double_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___gt__" "', argument " "1"" of type '" "VecMat::Vec<double,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2d___gt__" "', argument " "1"" of type '" "VecMat::Vec< double,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTdouble_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_double_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___gt__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2d___gt__" "', argument " "2"" of type '" "VecMat::Vec< double,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___gt__" "', argument " "2"" of type '" "VecMat::Vec<double,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2d___gt__" "', argument " "2"" of type '" "VecMat::Vec< double,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<double,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< double,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<double,2 > const *)arg1)->operator >((VecMat::Vec<double,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< double,2 > const *)arg1)->operator >((VecMat::Vec< double,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12896,19 +12716,19 @@ fail:
 
 SWIGINTERN PyObject *Vec_2d_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecTdouble_2_t, SWIG_NewClientData(obj));
+  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecT_double_2_t, SWIG_NewClientData(obj));
   return SWIG_Py_Void();
 }
 
 SWIGINTERN PyObject *_wrap_new_Vec_2f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *result = 0 ;
+  VecMat::Vec< float,2 > *result = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)":new_Vec_2f")) SWIG_fail;
   {
     try {
-      result = (VecMat::Vec<float,2 > *)new VecMat::Vec<float,2 >();
+      result = (VecMat::Vec< float,2 > *)new VecMat::Vec< float,2 >();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12917,7 +12737,7 @@ SWIGINTERN PyObject *_wrap_new_Vec_2f(PyObject *SWIGUNUSEDPARM(self), PyObject *
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTfloat_2_t, SWIG_POINTER_NEW |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecT_float_2_t, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -12926,17 +12746,17 @@ fail:
 
 SWIGINTERN PyObject *_wrap_delete_Vec_2f(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
+  VecMat::Vec< float,2 > *arg1 = (VecMat::Vec< float,2 > *) 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:delete_Vec_2f",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, SWIG_POINTER_DISOWN |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_float_2_t, SWIG_POINTER_DISOWN |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_2f" "', argument " "1"" of type '" "VecMat::Vec<float,2 > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vec_2f" "', argument " "1"" of type '" "VecMat::Vec< float,2 > *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp1);
   {
     try {
       delete arg1;
@@ -12963,7 +12783,7 @@ SWIGINTERN PyObject *_wrap_Vec_2f_dim(PyObject *SWIGUNUSEDPARM(self), PyObject *
   if (!PyArg_ParseTuple(args,(char *)":Vec_2f_dim")) SWIG_fail;
   {
     try {
-      result = (unsigned int)VecMat::Vec<float,2 >::SWIGTEMPLATEDISAMBIGUATOR dim();
+      result = (unsigned int)VecMat::Vec< float,2 >::SWIGTEMPLATEDISAMBIGUATOR dim();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -12981,21 +12801,21 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2f_norm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
-  VecMat::Vec<float,2 >::value_type result;
+  VecMat::Vec< float,2 > *arg1 = (VecMat::Vec< float,2 > *) 0 ;
+  VecMat::Vec< float,2 >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2f_norm",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f_norm" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f_norm" "', argument " "1"" of type '" "VecMat::Vec< float,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp1);
   {
     try {
-      result = (VecMat::Vec<float,2 >::value_type)((VecMat::Vec<float,2 > const *)arg1)->norm();
+      result = (VecMat::Vec< float,2 >::value_type)((VecMat::Vec< float,2 > const *)arg1)->norm();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13013,21 +12833,21 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2f_squareNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
-  VecMat::Vec<float,2 >::value_type result;
+  VecMat::Vec< float,2 > *arg1 = (VecMat::Vec< float,2 > *) 0 ;
+  VecMat::Vec< float,2 >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2f_squareNorm",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f_squareNorm" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f_squareNorm" "', argument " "1"" of type '" "VecMat::Vec< float,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp1);
   {
     try {
-      result = (VecMat::Vec<float,2 >::value_type)((VecMat::Vec<float,2 > const *)arg1)->squareNorm();
+      result = (VecMat::Vec< float,2 >::value_type)((VecMat::Vec< float,2 > const *)arg1)->squareNorm();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13045,23 +12865,23 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2f_normalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
-  VecMat::Vec<float,2 > *result = 0 ;
+  VecMat::Vec< float,2 > *arg1 = (VecMat::Vec< float,2 > *) 0 ;
+  VecMat::Vec< float,2 > *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2f_normalize",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f_normalize" "', argument " "1"" of type '" "VecMat::Vec<float,2 > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f_normalize" "', argument " "1"" of type '" "VecMat::Vec< float,2 > *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp1);
   {
     try {
       {
-        VecMat::Vec<float,2 > &_result_ref = (arg1)->normalize();
-        result = (VecMat::Vec<float,2 > *) &_result_ref;
+        VecMat::Vec< float,2 > &_result_ref = (arg1)->normalize();
+        result = (VecMat::Vec< float,2 > *) &_result_ref;
       }
     }
     //    catch (Swig::DirectorTypeMismatch&) {
@@ -13071,7 +12891,7 @@ SWIGINTERN PyObject *_wrap_Vec_2f_normalize(PyObject *SWIGUNUSEDPARM(self), PyOb
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -13080,23 +12900,23 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2f_normalizeSafe(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
-  VecMat::Vec<float,2 > *result = 0 ;
+  VecMat::Vec< float,2 > *arg1 = (VecMat::Vec< float,2 > *) 0 ;
+  VecMat::Vec< float,2 > *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec_2f_normalizeSafe",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec<float,2 > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f_normalizeSafe" "', argument " "1"" of type '" "VecMat::Vec< float,2 > *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp1);
   {
     try {
       {
-        VecMat::Vec<float,2 > &_result_ref = (arg1)->normalizeSafe();
-        result = (VecMat::Vec<float,2 > *) &_result_ref;
+        VecMat::Vec< float,2 > &_result_ref = (arg1)->normalizeSafe();
+        result = (VecMat::Vec< float,2 > *) &_result_ref;
       }
     }
     //    catch (Swig::DirectorTypeMismatch&) {
@@ -13106,7 +12926,7 @@ SWIGINTERN PyObject *_wrap_Vec_2f_normalizeSafe(PyObject *SWIGUNUSEDPARM(self),
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -13115,9 +12935,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2f___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
-  VecMat::Vec<float,2 > *arg2 = 0 ;
-  VecMat::Vec<float,2 > result;
+  VecMat::Vec< float,2 > *arg1 = (VecMat::Vec< float,2 > *) 0 ;
+  VecMat::Vec< float,2 > *arg2 = 0 ;
+  VecMat::Vec< float,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -13126,22 +12946,22 @@ SWIGINTERN PyObject *_wrap_Vec_2f___add__(PyObject *SWIGUNUSEDPARM(self), PyObje
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___add__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___add__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___add__" "', argument " "1"" of type '" "VecMat::Vec< float,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_float_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___add__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___add__" "', argument " "2"" of type '" "VecMat::Vec< float,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___add__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___add__" "', argument " "2"" of type '" "VecMat::Vec< float,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp2);
   {
     try {
-      result = ((VecMat::Vec<float,2 > const *)arg1)->operator +((VecMat::Vec<float,2 > const &)*arg2);
+      result = ((VecMat::Vec< float,2 > const *)arg1)->operator +((VecMat::Vec< float,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13150,7 +12970,7 @@ SWIGINTERN PyObject *_wrap_Vec_2f___add__(PyObject *SWIGUNUSEDPARM(self), PyObje
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<float,2 >(static_cast< const VecMat::Vec<float,2 >& >(result))), SWIGTYPE_p_VecMat__VecTfloat_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< float,2 >(static_cast< const VecMat::Vec< float,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_float_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -13159,9 +12979,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2f___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
-  VecMat::Vec<float,2 > *arg2 = 0 ;
-  VecMat::Vec<float,2 > result;
+  VecMat::Vec< float,2 > *arg1 = (VecMat::Vec< float,2 > *) 0 ;
+  VecMat::Vec< float,2 > *arg2 = 0 ;
+  VecMat::Vec< float,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -13170,22 +12990,22 @@ SWIGINTERN PyObject *_wrap_Vec_2f___sub__(PyObject *SWIGUNUSEDPARM(self), PyObje
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___sub__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___sub__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___sub__" "', argument " "1"" of type '" "VecMat::Vec< float,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_float_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___sub__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___sub__" "', argument " "2"" of type '" "VecMat::Vec< float,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___sub__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___sub__" "', argument " "2"" of type '" "VecMat::Vec< float,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp2);
   {
     try {
-      result = ((VecMat::Vec<float,2 > const *)arg1)->operator -((VecMat::Vec<float,2 > const &)*arg2);
+      result = ((VecMat::Vec< float,2 > const *)arg1)->operator -((VecMat::Vec< float,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13194,7 +13014,7 @@ SWIGINTERN PyObject *_wrap_Vec_2f___sub__(PyObject *SWIGUNUSEDPARM(self), PyObje
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<float,2 >(static_cast< const VecMat::Vec<float,2 >& >(result))), SWIGTYPE_p_VecMat__VecTfloat_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< float,2 >(static_cast< const VecMat::Vec< float,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_float_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -13203,9 +13023,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2f___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
-  VecMat::Vec<float,2 >::value_type arg2 ;
-  VecMat::Vec<float,2 > result;
+  VecMat::Vec< float,2 > *arg1 = (VecMat::Vec< float,2 > *) 0 ;
+  VecMat::Vec< float,2 >::value_type arg2 ;
+  VecMat::Vec< float,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   float val2 ;
@@ -13214,19 +13034,19 @@ SWIGINTERN PyObject *_wrap_Vec_2f___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self)
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___mul__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___mul__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___mul__" "', argument " "1"" of type '" "VecMat::Vec< float,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp1);
   ecode2 = SWIG_AsVal_float(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2f___mul__" "', argument " "2"" of type '" "VecMat::Vec<float,2 >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2f___mul__" "', argument " "2"" of type '" "VecMat::Vec< float,2 >::value_type""'");
   } 
-  arg2 = static_cast< VecMat::Vec<float,2 >::value_type >(val2);
+  arg2 = static_cast< VecMat::Vec< float,2 >::value_type >(val2);
   {
     try {
-      result = ((VecMat::Vec<float,2 > const *)arg1)->operator *(arg2);
+      result = ((VecMat::Vec< float,2 > const *)arg1)->operator *(arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13235,7 +13055,7 @@ SWIGINTERN PyObject *_wrap_Vec_2f___mul____SWIG_0(PyObject *SWIGUNUSEDPARM(self)
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<float,2 >(static_cast< const VecMat::Vec<float,2 >& >(result))), SWIGTYPE_p_VecMat__VecTfloat_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< float,2 >(static_cast< const VecMat::Vec< float,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_float_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -13244,9 +13064,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2f___div__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
-  VecMat::Vec<float,2 >::value_type arg2 ;
-  VecMat::Vec<float,2 > result;
+  VecMat::Vec< float,2 > *arg1 = (VecMat::Vec< float,2 > *) 0 ;
+  VecMat::Vec< float,2 >::value_type arg2 ;
+  VecMat::Vec< float,2 > result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   float val2 ;
@@ -13255,19 +13075,19 @@ SWIGINTERN PyObject *_wrap_Vec_2f___div__(PyObject *SWIGUNUSEDPARM(self), PyObje
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___div__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___div__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___div__" "', argument " "1"" of type '" "VecMat::Vec< float,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp1);
   ecode2 = SWIG_AsVal_float(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2f___div__" "', argument " "2"" of type '" "VecMat::Vec<float,2 >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vec_2f___div__" "', argument " "2"" of type '" "VecMat::Vec< float,2 >::value_type""'");
   } 
-  arg2 = static_cast< VecMat::Vec<float,2 >::value_type >(val2);
+  arg2 = static_cast< VecMat::Vec< float,2 >::value_type >(val2);
   {
     try {
-      result = ((VecMat::Vec<float,2 > const *)arg1)->operator /(arg2);
+      result = ((VecMat::Vec< float,2 > const *)arg1)->operator /(arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13276,7 +13096,7 @@ SWIGINTERN PyObject *_wrap_Vec_2f___div__(PyObject *SWIGUNUSEDPARM(self), PyObje
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj((new VecMat::Vec<float,2 >(static_cast< const VecMat::Vec<float,2 >& >(result))), SWIGTYPE_p_VecMat__VecTfloat_2_t, SWIG_POINTER_OWN |  0 );
+  resultobj = SWIG_NewPointerObj((new VecMat::Vec< float,2 >(static_cast< const VecMat::Vec< float,2 >& >(result))), SWIGTYPE_p_VecMat__VecT_float_2_t, SWIG_POINTER_OWN |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -13285,9 +13105,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2f___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
-  VecMat::Vec<float,2 > *arg2 = 0 ;
-  VecMat::Vec<float,2 >::value_type result;
+  VecMat::Vec< float,2 > *arg1 = (VecMat::Vec< float,2 > *) 0 ;
+  VecMat::Vec< float,2 > *arg2 = 0 ;
+  VecMat::Vec< float,2 >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   void *argp2 = 0 ;
@@ -13296,22 +13116,22 @@ SWIGINTERN PyObject *_wrap_Vec_2f___mul____SWIG_1(PyObject *SWIGUNUSEDPARM(self)
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___mul__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___mul__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___mul__" "', argument " "1"" of type '" "VecMat::Vec< float,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_float_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___mul__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___mul__" "', argument " "2"" of type '" "VecMat::Vec< float,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___mul__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___mul__" "', argument " "2"" of type '" "VecMat::Vec< float,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp2);
   {
     try {
-      result = (VecMat::Vec<float,2 >::value_type)((VecMat::Vec<float,2 > const *)arg1)->operator *((VecMat::Vec<float,2 > const &)*arg2);
+      result = (VecMat::Vec< float,2 >::value_type)((VecMat::Vec< float,2 > const *)arg1)->operator *((VecMat::Vec< float,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13333,17 +13153,17 @@ SWIGINTERN PyObject *_wrap_Vec_2f___mul__(PyObject *self, PyObject *args) {
   int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
+  argc = (int)PyObject_Length(args);
   for (ii = 0; (ii < argc) && (ii < 2); 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_VecMat__VecTfloat_2_t, 0);
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecT_float_2_t, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
-      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecTfloat_2_t, 0);
+      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_VecMat__VecT_float_2_t, 0);
       _v = SWIG_CheckState(res);
       if (_v) {
         return _wrap_Vec_2f___mul____SWIG_1(self, args);
@@ -13353,7 +13173,7 @@ SWIGINTERN PyObject *_wrap_Vec_2f___mul__(PyObject *self, PyObject *args) {
   if (argc == 2) {
     int _v;
     void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecTfloat_2_t, 0);
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__VecT_float_2_t, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
       {
@@ -13374,8 +13194,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2f___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
-  VecMat::Vec<float,2 > *arg2 = 0 ;
+  VecMat::Vec< float,2 > *arg1 = (VecMat::Vec< float,2 > *) 0 ;
+  VecMat::Vec< float,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -13385,22 +13205,22 @@ SWIGINTERN PyObject *_wrap_Vec_2f___eq__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___eq__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___eq__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___eq__" "', argument " "1"" of type '" "VecMat::Vec< float,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_float_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___eq__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___eq__" "', argument " "2"" of type '" "VecMat::Vec< float,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___eq__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___eq__" "', argument " "2"" of type '" "VecMat::Vec< float,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<float,2 > const *)arg1)->operator ==((VecMat::Vec<float,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< float,2 > const *)arg1)->operator ==((VecMat::Vec< float,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13418,8 +13238,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2f___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
-  VecMat::Vec<float,2 > *arg2 = 0 ;
+  VecMat::Vec< float,2 > *arg1 = (VecMat::Vec< float,2 > *) 0 ;
+  VecMat::Vec< float,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -13429,22 +13249,22 @@ SWIGINTERN PyObject *_wrap_Vec_2f___ne__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___ne__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___ne__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___ne__" "', argument " "1"" of type '" "VecMat::Vec< float,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_float_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___ne__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___ne__" "', argument " "2"" of type '" "VecMat::Vec< float,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___ne__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___ne__" "', argument " "2"" of type '" "VecMat::Vec< float,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<float,2 > const *)arg1)->operator !=((VecMat::Vec<float,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< float,2 > const *)arg1)->operator !=((VecMat::Vec< float,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13462,8 +13282,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2f___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
-  VecMat::Vec<float,2 > *arg2 = 0 ;
+  VecMat::Vec< float,2 > *arg1 = (VecMat::Vec< float,2 > *) 0 ;
+  VecMat::Vec< float,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -13473,22 +13293,22 @@ SWIGINTERN PyObject *_wrap_Vec_2f___lt__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___lt__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___lt__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___lt__" "', argument " "1"" of type '" "VecMat::Vec< float,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_float_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___lt__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___lt__" "', argument " "2"" of type '" "VecMat::Vec< float,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___lt__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___lt__" "', argument " "2"" of type '" "VecMat::Vec< float,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<float,2 > const *)arg1)->operator <((VecMat::Vec<float,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< float,2 > const *)arg1)->operator <((VecMat::Vec< float,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13506,8 +13326,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec_2f___gt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec<float,2 > *arg1 = (VecMat::Vec<float,2 > *) 0 ;
-  VecMat::Vec<float,2 > *arg2 = 0 ;
+  VecMat::Vec< float,2 > *arg1 = (VecMat::Vec< float,2 > *) 0 ;
+  VecMat::Vec< float,2 > *arg2 = 0 ;
   bool result;
   void *argp1 = 0 ;
   int res1 = 0 ;
@@ -13517,22 +13337,22 @@ SWIGINTERN PyObject *_wrap_Vec_2f___gt__(PyObject *SWIGUNUSEDPARM(self), PyObjec
   PyObject * obj1 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"OO:Vec_2f___gt__",&obj0,&obj1)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecTfloat_2_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__VecT_float_2_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___gt__" "', argument " "1"" of type '" "VecMat::Vec<float,2 > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec_2f___gt__" "', argument " "1"" of type '" "VecMat::Vec< float,2 > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp1);
-  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecTfloat_2_t,  0  | 0);
+  arg1 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp1);
+  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_VecMat__VecT_float_2_t,  0  | 0);
   if (!SWIG_IsOK(res2)) {
-    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___gt__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vec_2f___gt__" "', argument " "2"" of type '" "VecMat::Vec< float,2 > const &""'"); 
   }
   if (!argp2) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___gt__" "', argument " "2"" of type '" "VecMat::Vec<float,2 > const &""'"); 
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vec_2f___gt__" "', argument " "2"" of type '" "VecMat::Vec< float,2 > const &""'"); 
   }
-  arg2 = reinterpret_cast< VecMat::Vec<float,2 > * >(argp2);
+  arg2 = reinterpret_cast< VecMat::Vec< float,2 > * >(argp2);
   {
     try {
-      result = (bool)((VecMat::Vec<float,2 > const *)arg1)->operator >((VecMat::Vec<float,2 > const &)*arg2);
+      result = (bool)((VecMat::Vec< float,2 > const *)arg1)->operator >((VecMat::Vec< float,2 > const &)*arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13550,19 +13370,19 @@ fail:
 
 SWIGINTERN PyObject *Vec_2f_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *obj;
-  if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
-  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecTfloat_2_t, SWIG_NewClientData(obj));
+  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_VecMat__VecT_float_2_t, SWIG_NewClientData(obj));
   return SWIG_Py_Void();
 }
 
 SWIGINTERN PyObject *_wrap_new_Vec2u__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec2<unsigned int > *result = 0 ;
+  VecMat::Vec2< unsigned int > *result = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)":new_Vec2u")) SWIG_fail;
   {
     try {
-      result = (VecMat::Vec2<unsigned int > *)new VecMat::Vec2<unsigned int >();
+      result = (VecMat::Vec2< unsigned int > *)new VecMat::Vec2< unsigned int >();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13571,7 +13391,7 @@ SWIGINTERN PyObject *_wrap_new_Vec2u__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyO
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, SWIG_POINTER_NEW |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2T_unsigned_int_t, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -13580,9 +13400,9 @@ fail:
 
 SWIGINTERN PyObject *_wrap_new_Vec2u__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec2<unsigned int >::value_type arg1 ;
-  VecMat::Vec2<unsigned int >::value_type arg2 ;
-  VecMat::Vec2<unsigned int > *result = 0 ;
+  VecMat::Vec2< unsigned int >::value_type arg1 ;
+  VecMat::Vec2< unsigned int >::value_type arg2 ;
+  VecMat::Vec2< unsigned int > *result = 0 ;
   unsigned int val1 ;
   int ecode1 = 0 ;
   unsigned int val2 ;
@@ -13593,17 +13413,17 @@ SWIGINTERN PyObject *_wrap_new_Vec2u__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyO
   if (!PyArg_ParseTuple(args,(char *)"OO:new_Vec2u",&obj0,&obj1)) SWIG_fail;
   ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec2u" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec2u" "', argument " "1"" of type '" "VecMat::Vec2< unsigned int >::value_type""'");
   } 
-  arg1 = static_cast< VecMat::Vec2<unsigned int >::value_type >(val1);
+  arg1 = static_cast< VecMat::Vec2< unsigned int >::value_type >(val1);
   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
   if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec2u" "', argument " "2"" of type '" "VecMat::Vec2<unsigned int >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vec2u" "', argument " "2"" of type '" "VecMat::Vec2< unsigned int >::value_type""'");
   } 
-  arg2 = static_cast< VecMat::Vec2<unsigned int >::value_type >(val2);
+  arg2 = static_cast< VecMat::Vec2< unsigned int >::value_type >(val2);
   {
     try {
-      result = (VecMat::Vec2<unsigned int > *)new VecMat::Vec2<unsigned int >(arg1,arg2);
+      result = (VecMat::Vec2< unsigned int > *)new VecMat::Vec2< unsigned int >(arg1,arg2);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13612,7 +13432,7 @@ SWIGINTERN PyObject *_wrap_new_Vec2u__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyO
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, SWIG_POINTER_NEW |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2T_unsigned_int_t, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -13621,8 +13441,8 @@ fail:
 
 SWIGINTERN PyObject *_wrap_new_Vec2u__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec2<unsigned int >::value_type arg1 ;
-  VecMat::Vec2<unsigned int > *result = 0 ;
+  VecMat::Vec2< unsigned int >::value_type arg1 ;
+  VecMat::Vec2< unsigned int > *result = 0 ;
   unsigned int val1 ;
   int ecode1 = 0 ;
   PyObject * obj0 = 0 ;
@@ -13630,12 +13450,12 @@ SWIGINTERN PyObject *_wrap_new_Vec2u__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyO
   if (!PyArg_ParseTuple(args,(char *)"O:new_Vec2u",&obj0)) SWIG_fail;
   ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
   if (!SWIG_IsOK(ecode1)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec2u" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int >::value_type""'");
+    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Vec2u" "', argument " "1"" of type '" "VecMat::Vec2< unsigned int >::value_type""'");
   } 
-  arg1 = static_cast< VecMat::Vec2<unsigned int >::value_type >(val1);
+  arg1 = static_cast< VecMat::Vec2< unsigned int >::value_type >(val1);
   {
     try {
-      result = (VecMat::Vec2<unsigned int > *)new VecMat::Vec2<unsigned int >(arg1);
+      result = (VecMat::Vec2< unsigned int > *)new VecMat::Vec2< unsigned int >(arg1);
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13644,7 +13464,7 @@ SWIGINTERN PyObject *_wrap_new_Vec2u__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyO
       cout << "Warning: director exception catched" << endl;
     }
   }
-  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, SWIG_POINTER_NEW |  0 );
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_VecMat__Vec2T_unsigned_int_t, SWIG_POINTER_NEW |  0 );
   return resultobj;
 fail:
   return NULL;
@@ -13657,7 +13477,7 @@ SWIGINTERN PyObject *_wrap_new_Vec2u(PyObject *self, PyObject *args) {
   int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
+  argc = (int)PyObject_Length(args);
   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
@@ -13692,28 +13512,32 @@ SWIGINTERN PyObject *_wrap_new_Vec2u(PyObject *self, PyObject *args) {
   }
   
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vec2u'.\n  Possible C/C++ prototypes are:\n    VecMat::Vec2<(unsigned int)>()\n    VecMat::Vec2<(unsigned int)>(VecMat::Vec2<unsigned int >::value_type const,VecMat::Vec2<unsigned int >::value_type const)\n    VecMat::Vec2<(unsigned int)>(VecMat::Vec2<unsigned int >::value_type const)\n");
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_Vec2u'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    VecMat::Vec2< unsigned int >()\n"
+    "    VecMat::Vec2< unsigned int >(VecMat::Vec2< unsigned int >::value_type const,VecMat::Vec2< unsigned int >::value_type const)\n"
+    "    VecMat::Vec2< unsigned int >(VecMat::Vec2< unsigned int >::value_type const)\n");
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_Vec2u_x__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
-  VecMat::Vec2<unsigned int >::value_type result;
+  VecMat::Vec2< unsigned int > *arg1 = (VecMat::Vec2< unsigned int > *) 0 ;
+  VecMat::Vec2< unsigned int >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec2u_x",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2T_unsigned_int_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u_x" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int > const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u_x" "', argument " "1"" of type '" "VecMat::Vec2< unsigned int > const *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec2< unsigned int > * >(argp1);
   {
     try {
-      result = (VecMat::Vec2<unsigned int >::value_type)((VecMat::Vec2<unsigned int > const *)arg1)->x();
+      result = (VecMat::Vec2< unsigned int >::value_type)((VecMat::Vec2< unsigned int > const *)arg1)->x();
     }
     //    catch (Swig::DirectorTypeMismatch&) {
     //      cout << "Warning: return type mismatch" << endl;
@@ -13731,23 +13555,23 @@ fail:
 
 SWIGINTERN PyObject *_wrap_Vec2u_x__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
-  VecMat::Vec2<unsigned int >::value_type *result = 0 ;
+  VecMat::Vec2< unsigned int > *arg1 = (VecMat::Vec2< unsigned int > *) 0 ;
+  VecMat::Vec2< unsigned int >::value_type *result = 0 ;
   void *argp1 = 0 ;
   int res1 = 0 ;
   PyObject * obj0 = 0 ;
   
   if (!PyArg_ParseTuple(args,(char *)"O:Vec2u_x",&obj0)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0 |  0 );
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_VecMat__Vec2T_unsigned_int_t, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u_x" "', argument " "1"" of type '" "VecMat::Vec2<unsigned int > *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vec2u_x" "', argument " "1"" of type '" "VecMat::Vec2< unsigned int > *""'"); 
   }
-  arg1 = reinterpret_cast< VecMat::Vec2<unsigned int > * >(argp1);
+  arg1 = reinterpret_cast< VecMat::Vec2< unsigned int > * >(argp1);
   {
     try {
       {
-        VecMat::Vec2<unsigned int >::value_type &_result_ref = (arg1)->x();
-        result = (VecMat::Vec2<unsigned int >::value_type *) &_result_ref;
+        VecMat::Vec2< unsigned int >::value_type &_result_ref = (arg1)->x();
+        result = (VecMat::Vec2< unsigned int >::value_type *) &_result_ref;
       }
     }
     //    catch (Swig::DirectorTypeMismatch&) {
@@ -13770,14 +13594,14 @@ SWIGINTERN PyObject *_wrap_Vec2u_x(PyObject *self, PyObject *args) {
   int ii;
   
   if (!PyTuple_Check(args)) SWIG_fail;
-  argc = PyObject_Length(args);
+  argc = (int)PyObject_Length(args);
   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
     argv[ii] = PyTuple_GET_ITEM(args,ii);
   }
   if (argc == 1) {
     int _v;
     void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0);
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2T_unsigned_int_t, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_Vec2u_x__SWIG_0(self, args);
@@ -13786,7 +13610,7 @@ SWIGINTERN PyObject *_wrap_Vec2u_x(PyObject *self, PyObject *args) {
   if (argc == 1) {
     int _v;
     void *vptr = 0;
-    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2Tunsigned_int_t, 0);
+    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_VecMat__Vec2T_unsigned_int_t, 0);
     _v = SWIG_CheckState(res);
     if (_v) {
       return _wrap_Vec2u_x__SWIG_1(self, args);
@@ -13794,28 +13618,31 @@ SWIGINTERN PyObject *_wrap_Vec2u_x(PyObject *self, PyObject *args) {
   }
   
 fail:
-  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec2u_x'.\n  Possible C/C++ prototypes are:\n    x()\n    x()\n");
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Vec2u_x'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    x(VecMat::Vec2< unsigned int > const *)\n"
+    "    x(VecMat::Vec2< unsigned int > *)\n");
   return NULL;
 }
 
 
 SWIGINTERN PyObject *_wrap_Vec2u_y__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
-  VecMat::Vec2<unsigned int > *arg1 = (VecMat::Vec2<unsigned int > *) 0 ;
-  VecMat::Vec2<unsigned int >::value_type result;
+  VecMat::Vec2< unsigned int > *arg1 = (VecMat::Vec2< unsigned int > *) 0 ;
+  VecMat::Vec2< unsigned int >::value_type result;
   void *argp1 = 0 ;
   int res1 = 0