/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 3.0.11
 *
 * 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
 * changes to this file unless you know what you are doing--modify the SWIG
 * interface file instead.
 * ----------------------------------------------------------------------------- */

#define SWIGMATLAB
#define SWIG_name_d      "iDynTree"
#define SWIG_name        iDynTree

#define SWIG_op_prefix        "op_"
#define SWIG_pkg_name        "iDynTree"
#define SwigVar_mxArray mxArray*


#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# 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
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# 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

/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif

/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif


/* Workaround, Octave's mex.h lacks uint64_t */
#include <stdint.h>
/* MATLAB's C-API */
#include <mex.h>
/* MISC C libraries */
#include <math.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <limits.h>

/* -----------------------------------------------------------------------------
 * swigrun.swg
 *
 * This file contains generic C API SWIG runtime support for pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

/* 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 "4"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the SWIG runtime code.
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.

  But only do this if strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

/*  Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif

/* 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


/*
   Flags/methods for returning states.

   The SWIG conversion methods, as ConvertPtr, return an integer
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).

   Use the following macros/flags to set or process the returning
   states.

   In old versions of SWIG, code such as the following was usually written:

     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
       // success code
     } else {
       //fail code
     }

   Now you can be more explicit:

    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
    } else {
      // fail code
    }

   which is the same really, but now you can also do

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
	delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }

   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

      int SWIG_ConvertPtr(obj, ptr,...) {
        if (<obj is ok>) {
          if (<need new object>) {
            *ptr = <ptr to new allocated object>;
            return SWIG_NEWOBJ;
          } else {
            *ptr = <ptr to old object>;
            return SWIG_OLDOBJ;
          }
        } else {
          return SWIG_BADOBJ;
        }
      }

   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
   SWIG errors code.

   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
   allows to return the 'cast rank', for example, if you have this

       int food(double)
       int fooi(int);

   and you call

      food(1)   // cast rank '1'  (1 -> 1.0)
      fooi(1)   // cast rank '0'

   just use the SWIG_AddCast()/SWIG_CheckState()
*/

#define SWIG_OK                    (0)
#define SWIG_ERROR                 (-1)
#define SWIG_IsOK(r)               (r >= 0)
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)

/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT         (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ                (SWIG_ERROR)
#define SWIG_OLDOBJ                (SWIG_OK)
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del mask methods */
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
#  ifndef SWIG_TypeRank
#    define SWIG_TypeRank             unsigned long
#  endif
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
#    define SWIG_MAXCASTRANK          (2)
#  endif
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
#  define SWIG_AddCast(r) (r)
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

/* 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 */
  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
  void                   *clientdata;		/* language specific type data */
  int                    owndata;		/* flag if the structure owns the clientdata */
} swig_type_info;

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
  swig_converter_func     converter;		/* function to cast the void pointers */
  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
  struct swig_cast_info  *prev;			/* pointer to the previous cast */
} swig_cast_info;

/* Structure used to store module information
 * Each module generates one structure like this, and the runtime collects
 * all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
  size_t                 size;		        /* Number of types in this module */
  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
  swig_type_info         **type_initial;	/* Array of initially generated type structures */
  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
  void                    *clientdata;		/* Language specific module data */
} swig_module_info;

/*
  Compare two type names skipping the space characters, therefore
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.

  Return 0 when the two name types are equivalent, as in
  strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
		  const char *f2, const char *l2) {
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
  }
  return (int)((l1 - f1) - (l2 - f2));
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
  int equiv = 1;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (equiv != 0 && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (strcmp(iter->type->name, c) == 0) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (iter->type == from) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}

/*
   Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
  swig_type_info *lastty = ty;
  if (!ty || !ty->dcast) return ty;
  while (ty && (ty->dcast)) {
    ty = (*ty->dcast)(ptr);
    if (ty) lastty = ty;
  }
  return lastty;
}

/*
  Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  We choose
     to print the last name, as it is often (?) the most
     specific. */
  if (!type) return NULL;
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

/*
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *cast = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (cast) {
    if (!cast->converter) {
      swig_type_info *tc = cast->type;
      if (!tc->clientdata) {
	SWIG_TypeClientData(tc, clientdata);
      }
    }
    cast = cast->next;
  }
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}

/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
                            swig_module_info *end,
		            const char *name) {
  swig_module_info *iter = start;
  do {
    if (iter->size) {
      size_t l = 0;
      size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	size_t i = (l + r) >> 1;
	const char *iname = iter->types[i]->name;
	if (iname) {
	  int compare = strcmp(name, iname);
	  if (compare == 0) {
	    return iter->types[i];
	  } else if (compare < 0) {
	    if (i) {
	      r = i - 1;
	    } else {
	      break;
	    }
	  } else if (compare > 0) {
	    l = i + 1;
	  }
	} else {
	  break; /* should never happen */
	}
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

/*
  Search for a swig_type_info structure for either a mangled name or a human readable name.
  It first searches the mangled names of the types, which is a O(log #types)
  If a type is not found it then searches the human readable names, which is O(#types).

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
                     swig_module_info *end,
		     const char *name) {
  /* STEP 1: Search the name field using binary search */
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
  if (ret) {
    return ret;
  } else {
    /* STEP 2: If the type hasn't been found, do a complete search
       of the str field (the human readable name) */
    swig_module_info *iter = start;
    do {
      size_t i = 0;
      for (; i < iter->size; ++i) {
	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
	  return iter->types[i];
      }
      iter = iter->next;
    } while (iter != end);
  }

  /* neither found a match */
  return 0;
}

/*
   Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
  static const char hex[17] = "0123456789abcdef";
  const unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    unsigned char uu = *u;
    *(c++) = hex[(uu & 0xf0) >> 4];
    *(c++) = hex[uu & 0xf];
  }
  return c;
}

/*
   Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
  unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu = u + sz;
  for (; u != eu; ++u) {
    char d = *(c++);
    unsigned char uu;
    if ((d >= '0') && (d <= '9'))
      uu = (unsigned char)((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = (unsigned char)((d - ('a'-10)) << 4);
    else
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (unsigned char)(d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (unsigned char)(d - ('a'-10));
    else
      return (char *) 0;
    *u = uu;
  }
  return c;
}

/*
   Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
  char *r = buff;
  if ((2*sizeof(void *) + 2) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,&ptr,sizeof(void *));
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
  strcpy(r,name);
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      *ptr = (void *) 0;
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
}

SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
  char *r = buff;
  size_t lname = (name ? strlen(name) : 0);
  if ((2*sz + 2 + lname) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  if (lname) {
    strncpy(r,name,lname+1);
  } else {
    *r = 0;
  }
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      memset(ptr,0,sz);
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sz);
}

#ifdef __cplusplus
}
#endif

/*  Errors in SWIG */
#define  SWIG_UnknownError    	   -1
#define  SWIG_IOError        	   -2
#define  SWIG_RuntimeError   	   -3
#define  SWIG_IndexError     	   -4
#define  SWIG_TypeError      	   -5
#define  SWIG_DivisionByZero 	   -6
#define  SWIG_OverflowError  	   -7
#define  SWIG_SyntaxError    	   -8
#define  SWIG_ValueError     	   -9
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12
#define  SWIG_NullReferenceError   -13



/* Last error */
static int SWIG_lasterror_code = 0;
static char SWIG_lasterror_msg[65536];
SWIGRUNTIME void SWIG_Error(int code, const char *format, ...) {
  SWIG_lasterror_code = code;
  va_list arg;
  va_start(arg, format);
  vsnprintf(SWIG_lasterror_msg, sizeof(SWIG_lasterror_msg), format, arg);
  va_end(arg);
}

SWIGRUNTIME const char* SWIG_ErrorType(int code) {
  switch (code) {
  case SWIG_MemoryError:
    return "SWIG:MemoryError";
  case SWIG_IOError:
    return "SWIG:IOError";
  case SWIG_RuntimeError:
    return "SWIG:RuntimeError";
  case SWIG_IndexError:
    return "SWIG:IndexError";
  case SWIG_TypeError:
    return "SWIG:TypeError";
  case SWIG_DivisionByZero:
    return "SWIG:DivisionByZero";
  case SWIG_OverflowError:
    return "SWIG:OverflowError";
  case SWIG_SyntaxError:
    return "SWIG:SyntaxError";
  case SWIG_ValueError:
    return "SWIG:ValueError";
  case SWIG_SystemError:
    return "SWIG:SystemError";
  case SWIG_AttributeError:
    return "SWIG:AttributeError";
  }
  return "SWIG:UnknownError";
}

SWIGRUNTIME int SWIG_check_num_args(const char *func_name, int num_args, int max_args, int min_args, int varargs) {
  if (num_args > max_args && !varargs) {
    SWIG_Error(SWIG_RuntimeError, "function %s takes at most %i arguments", func_name, max_args);
  } else if (num_args < min_args) {
    SWIG_Error(SWIG_RuntimeError, "function %s requires at least %i arguments", func_name, min_args);
  } else {
    return 1;
  }
  return 0;
}

#define SWIG_fail                                       goto fail

#define SWIG_Matlab_ConvertPtr(obj, pptr, type, flags)  SWIG_Matlab_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Matlab_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Matlab_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Matlab_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Matlab_NewPointerObj(ptr, type, flags)
#define swig_owntype                                    int

#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Matlab_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Matlab_NewPackedObj(ptr, sz, type)

#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)

#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Matlab_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Matlab_NewPackedObj(ptr, sz, type)

#define SWIG_GetModule(clientdata)                      SWIG_Matlab_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer)             SWIG_Matlab_SetModule(pointer);
#define SWIG_MODULE_CLIENTDATA_TYPE void*

#define Matlab_Error_Occurred() 0
#define SWIG_Matlab_AddErrorMsg(msg) {;}

SWIGRUNTIME swig_module_info *SWIG_Matlab_GetModule(void *clientdata);
SWIGRUNTIME void SWIG_Matlab_SetModule(swig_module_info *pointer);

/* For backward compatibility only */
#define SWIG_POINTER_EXCEPTION  0
#define SWIG_arg_fail(arg)      0

/* Pointer to C/C++ object, including type information and reference counters */
typedef struct SwigPtr {
  void *ptr;
  swig_type_info *type;
  int own;
  void *self;
  struct SwigPtr* next;
} SwigPtr;
static swig_module_info *saved_swig_module = 0;

/* Add new pointer object to the memory allocator
   Returns the location of the new element by reference and a return flag by value.
 */
int SWIG_Matlab_NewPointer(SwigPtr** swig_ptr, void *ptr, swig_type_info *type, int own) {
  /* Check input arguments */
  if (!swig_ptr || !type) return 1;

  /* Allocate memory */
  SwigPtr *obj=(SwigPtr *)malloc(sizeof(SwigPtr));
  if (!obj) return 1;

  /* Initialize object */
  obj->ptr = ptr;
  obj->type = type;
  obj->own = own;
  obj->self = obj;
  obj->next = 0;

  /* Return memory reference and successful return */
  *swig_ptr = obj;
  return 0;
}

/* Free pointer object
   Returns a void* with the object to be freed (if any)
 */
void* SWIG_Matlab_DeletePointer(SwigPtr* p) {
  /* Quick return if null pointer? */
  if (p==0) return 0;

  /* Clear and free */
  void* ret = p->own ? p->ptr : 0;
  p->ptr=0;
  p->type=0;
  p->own=0;
  p->self=0;
  p->next=0;
  free(p);
  return ret;
}

/* This should probably be moved somewhere else */
#ifdef __cplusplus
extern "C"
#endif /* cplusplus */
void SWIG_Matlab_ExitFcn(void) {
  /* Unused at the moment */
}

SWIGRUNTIME int
SWIG_Matlab_CallInterp(int nlhs, mxArray *plhs[], int nrhs,
                       mxArray *prhs[], const char *functionName) {
#ifdef HAVE_OCTAVE
  return mexCallMATLAB(nlhs, plhs, nrhs, prhs, functionName);
#else
  mxArray* ex = mexCallMATLABWithTrap(nlhs, plhs, nrhs, prhs, functionName);
  if (ex) {
    mxDestroyArray(ex);
    return 1;
  } else {
    return 0;
  }
#endif
}

SWIGRUNTIME mxArray*
SWIG_Matlab_CallInterpEx(int nlhs, mxArray *plhs[], int nrhs,
                       mxArray *prhs[], const char *functionName) {
#ifdef HAVE_OCTAVE
  int flag = mexCallMATLAB(nlhs, plhs, nrhs, prhs, functionName);
  if (flag) {
    mexErrMsgIdAndTxt("SWIG:CallInterpEx","Not implemented for Octave");
  }
  return 0;
#else
  return mexCallMATLABWithTrap(nlhs, plhs, nrhs, prhs, functionName);
#endif
}

/* Convert a packed value value */
SWIGRUNTIME int
SWIG_Matlab_ConvertPacked(mxArray* SWIGUNUSEDPARM(pm), void* SWIGUNUSEDPARM(ptr), size_t SWIGUNUSEDPARM(sz), swig_type_info* SWIGUNUSEDPARM(ty)) {
  mexErrMsgIdAndTxt("SWIG:ConvertPacked","Not implemented");
  return SWIG_ERROR;
}

/* Runtime API implementation */
SWIGRUNTIME mxArray* SWIG_Matlab_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
  /* Ownership? */
  int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;

  /* Allocate a pointer object */
  SwigPtr* swig_ptr = 0;
  if (SWIG_Matlab_NewPointer(&swig_ptr, ptr, type, own)) {
    mexErrMsgIdAndTxt("SWIG:NewPointerObj","Cannot allocate pointer");
  }

  /* Create a SwigRef instance */
  mxArray* pm = 0;
  int ex = SWIG_Matlab_CallInterp(1, &pm, 0, 0, "SwigRef");
  if (ex) mexErrMsgIdAndTxt("SWIG:NewPointerObj", "Cannot create SwigRef instance");

  /* Set pointer property */
  mxArray *pm_ptr = mxCreateNumericMatrix(1, 1, mxUINT64_CLASS, mxREAL);
  *(uint64_T *)mxGetData(pm_ptr) = (uint64_T)swig_ptr;
  if(!pm_ptr) mexErrMsgIdAndTxt("SWIG:NewPointerObj", "mxCreateNumericMatrix failed");

  mxArray *rhs[2] = {pm, pm_ptr};
  mexCallMATLAB(0, 0, 2, rhs, "SwigSet");
  mxDestroyArray(pm_ptr);

  /* Create a proxy class of the desired type */
  if (type->clientdata) {
    const char* matlab_classname = (const char *)type->clientdata;
    mxArray* pm_test = 0;
    ex = SWIG_Matlab_CallInterp(1, &pm_test, 1, &pm, matlab_classname);
    if (ex) {
      mexWarnMsgIdAndTxt("SWIG:NewPointerObj",
                         "NewPointerObj problem. creating SwigRef as opposed to %s", matlab_classname);
    } else {
      mxDestroyArray(pm);
      pm = pm_test;
    }
  }

  return pm;
}

/* Create a new packed object */

SWIGRUNTIMEINLINE mxArray*
SWIG_Matlab_NewPackedObj(void* SWIGUNUSEDPARM(ptr), size_t SWIGUNUSEDPARM(sz), swig_type_info* SWIGUNUSEDPARM(type)) {
  mexErrMsgIdAndTxt("SWIG:NewPackedOb","Not implemented");
  return 0;
}

SWIGRUNTIME int SWIG_Matlab_isOwned(mxArray* pm) {
/* Get index, represented as a uint64_T scalar */
  mxArray *pm_ptr;
  mexCallMATLAB(1, &pm_ptr, 1, &pm, "SwigGet");
  if(!pm_ptr || mxGetNumberOfElements(pm_ptr) != 1 ||
     mxGetClassID(pm_ptr) != mxUINT64_CLASS || mxIsComplex(pm_ptr)) {
    if(pm_ptr) mxDestroyArray(pm_ptr);
    return SWIG_ERROR;
  }
  SwigPtr* p = (SwigPtr*)(*(uint64_T*)mxGetData(pm_ptr));
  mxDestroyArray(pm_ptr);

  return p ? p->own : 0;
}

SWIGRUNTIME SwigPtr* SWIG_Matlab_getSwigPtr(mxArray* pm) {
/* Get index, represented as a uint64_T scalar */
  mxArray *pm_ptr;
  mexCallMATLAB(1, &pm_ptr, 1, &pm, "SwigGet");
  if(!pm_ptr || mxGetNumberOfElements(pm_ptr) != 1 ||
     mxGetClassID(pm_ptr) != mxUINT64_CLASS || mxIsComplex(pm_ptr)) {
    if(pm_ptr) mxDestroyArray(pm_ptr);
    return 0;
  }
  SwigPtr* p = (SwigPtr*)(*(uint64_T*)mxGetData(pm_ptr));
  mxDestroyArray(pm_ptr);

  /* Consistency check */
  if (p->self != p) return 0;

  /* Get pointer object */
  return p;
}

SWIGRUNTIME int SWIG_Matlab_ConvertPtrAndOwn(mxArray* pm, void **ptr, swig_type_info *type, int flags, int *own) {
  /* Get index, represented as a uint64_T scalar */
  mxArray *pm_ptr;
  mexCallMATLAB(1, &pm_ptr, 1, &pm, "SwigGet");
  if(!pm_ptr || mxGetNumberOfElements(pm_ptr) != 1 ||
     mxGetClassID(pm_ptr) != mxUINT64_CLASS || mxIsComplex(pm_ptr)){
    if(pm_ptr) mxDestroyArray(pm_ptr);
    return SWIG_ERROR;
  }
  SwigPtr* swig_ptr = (SwigPtr*)(*(uint64_T*)mxGetData(pm_ptr));
  mxDestroyArray(pm_ptr);

  /* Get pointer object */
  if (!swig_ptr) return SWIG_ERROR;

  swig_cast_info *tc;
  int same_type = 0;
  SwigPtr* p=swig_ptr;
  while (p) {
    /* Loop over types */
    swig_type_info *p_type = p->type;

    /* No type cast needed */
    if (p_type==type || !type) {
      same_type = 1;
      break;
    }

    /* Check if type conversion is possible */
    tc = SWIG_TypeCheck(p_type->name, type);
    if (tc) break;

    /* Check next type */
    p = p->next;
  }

  /* Conversion not possible */
  if (!same_type && !tc) return SWIG_ERROR;

  /* Get data */
  if (ptr) *ptr = p->ptr;
  if (own) *own = p->own;

  /* Set ownership marker to false? */
  if(flags & SWIG_POINTER_DISOWN){
    SWIG_Matlab_DeletePointer(swig_ptr);
  }

  /* No type cast needed */
  if (same_type || !ptr) {
    return SWIG_OK;
  }

  /* Do type-cast */
  int newmemory = 0;
  *ptr = SWIG_TypeCast(tc, *ptr, &newmemory);
  if (newmemory == SWIG_CAST_NEW_MEMORY) {
    if (own) {
      *own = *own | SWIG_CAST_NEW_MEMORY;
    } else {
      /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
      mexErrMsgIdAndTxt("SWIG:ConvertPointerObj","SWIG error in converting pointer for type %s. Bad typemap?",type->name);
      return SWIG_ERROR;
    }
  }
  return SWIG_OK;
}

SWIGRUNTIME swig_module_info *SWIG_Matlab_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
  if (!saved_swig_module) {
    /* First call for this module, fetch pointer from MATLAB */
    mxArray* mem = 0;
    int flag = mexCallMATLAB(1, &mem, 0, 0, "SwigMem");
    if (flag || !mem) mexErrMsgIdAndTxt("SWIG:GetModule", "Cannot call SwigMem");
    /* On first call, mem is an empty matrix */
    if (mxGetNumberOfElements(mem)!= 0) {
      if (!mxIsStruct(mem)) {
        mexErrMsgIdAndTxt("SWIG:GetModule", "Corrupted memory");
      }
      mxArray *module = mxGetField(mem, 0,
        "swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
      if (module && mxGetNumberOfElements(module) == 1 && mxGetClassID(module) == mxUINT64_CLASS && !mxIsComplex(module)) {
        /* Cast memory as a pointer */
        saved_swig_module = (swig_module_info*)(*(uint64_T*)mxGetData(module));
      }
    }
    mxDestroyArray(mem);
  }
  return saved_swig_module;
}

SWIGRUNTIME void SWIG_Matlab_SetModule(swig_module_info *pointer) {
  mxArray* mem = 0;
  const char *fields[1] = {"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME};
  int flag = mexCallMATLAB(1, &mem, 0, 0, "SwigMem");
  if (flag || !mem) mexErrMsgIdAndTxt("SWIG:SetModule", "Cannot call SwigMem");
  /* Under normal circumstances, swigMem is an empty matrix */
  /* but is not required to be for a valid call to SWIG_Matlab_SetModule() */
  if (mxGetNumberOfElements(mem) == 0) {
    mxDestroyArray(mem);
    mem = mxCreateStructMatrix(1,1,1,fields);
    if(!mem) mexErrMsgIdAndTxt("SWIG:SetModule","mxCreateStructMatrix failed");
    mxArray *module = mxCreateNumericMatrix(1, 1, mxUINT64_CLASS, mxREAL);
    if(!module) mexErrMsgIdAndTxt("SWIG:SetModule","mxCreateNumericMatrix failed");
    *(uint64_T *)mxGetData(module) = (uint64_T)pointer;
    mxSetField(mem, 0, fields[0], module);
  } else {
    int nfields = 0;
    int fieldNum = 0;
    /* Add to existing mem if not the same */
    if (!mxIsStruct(mem)) {
      mexErrMsgIdAndTxt("SWIG:SetModule", "Corrupted memory");
    }
    nfields = mxGetNumberOfFields(mem);
    /* Check if same type table */
    int ii;
    for (ii=0; ii<nfields; ++ii){
      if(strcmp(mxGetFieldNameByNumber(mem, ii), fields[0]) == 0) {
        mxDestroyArray(mem);
        return;
      }
    }
    fieldNum = mxAddField(mem, fields[0]);
    if (fieldNum < 0) mexErrMsgIdAndTxt("SWIG:SetModule", "Error adding field to SwigMem");
    mxArray *module = mxCreateNumericMatrix(1, 1, mxUINT64_CLASS, mxREAL);
    if(!module) mexErrMsgIdAndTxt("SWIG:SetModule","mxCreateNumericMatrix failed");
    *(uint64_T *)mxGetData(module) = (uint64_T)pointer;
    mxSetFieldByNumber(mem, 0, fieldNum, module);
  }
  /* Set variable in SwigMem */
  flag = mexCallMATLAB(0, 0, 1, &mem, "SwigMem");
  mxDestroyArray(mem);
  if (flag) {
    mexErrMsgIdAndTxt("SWIG:SetModule", "Could not set variable in SwigMem.\n");
  }
  saved_swig_module = pointer;
}

/* HACK HACK */
#define SWIG_Matlab_SetConstant(dummy1,dummy2,pm) (pm)

#ifdef __cplusplus
#include <streambuf>
#include <iostream>
namespace swig {
  // Stream buffer to allow redirecting output to MATLAB
  class SWIG_Matlab_streambuf : public std::streambuf {
  public:
    SWIG_Matlab_streambuf() {}
  protected:
    virtual int_type overflow(int_type ch) {
      if(ch != traits_type::eof()) {
        mexPrintf("%c", static_cast<char>(ch));
      }
      return ch;
    }
    virtual std::streamsize xsputn(const char* s, std::streamsize num) {
      // Pass straight to mexPrintf without buffering
      mexPrintf("%.*s", static_cast<int>(num), s);
      return num;
    }
  };

  // Instantiation
  static SWIG_Matlab_streambuf SWIG_Matlab_buf;
} // namespace swig
#endif /* cplusplus */



#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 

#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 



  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) 


/* -------- TYPES TABLE (BEGIN) -------- */

#define SWIGTYPE_p_AngularVector3T swig_types[0]
#define SWIGTYPE_p_DualVectorT swig_types[1]
#define SWIGTYPE_p_LinearVector3T swig_types[2]
#define SWIGTYPE_p_Type swig_types[3]
#define SWIGTYPE_p_allocator_type swig_types[4]
#define SWIGTYPE_p_char swig_types[5]
#define SWIGTYPE_p_const_iterator swig_types[6]
#define SWIGTYPE_p_const_pointer swig_types[7]
#define SWIGTYPE_p_const_reference swig_types[8]
#define SWIGTYPE_p_const_reverse_iterator swig_types[9]
#define SWIGTYPE_p_const_typed_iterator swig_types[10]
#define SWIGTYPE_p_difference_type swig_types[11]
#define SWIGTYPE_p_double swig_types[12]
#define SWIGTYPE_p_element_type swig_types[13]
#define SWIGTYPE_p_iDynTree__AccelerometerSensor swig_types[14]
#define SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers swig_types[15]
#define SWIGTYPE_p_iDynTree__ArticulatedBodyInertia swig_types[16]
#define SWIGTYPE_p_iDynTree__AttitudeEstimatorState swig_types[17]
#define SWIGTYPE_p_iDynTree__AttitudeMahonyFilter swig_types[18]
#define SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters swig_types[19]
#define SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF swig_types[20]
#define SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters swig_types[21]
#define SWIGTYPE_p_iDynTree__Axis swig_types[22]
#define SWIGTYPE_p_iDynTree__BerdyDynamicVariable swig_types[23]
#define SWIGTYPE_p_iDynTree__BerdyHelper swig_types[24]
#define SWIGTYPE_p_iDynTree__BerdyOptions swig_types[25]
#define SWIGTYPE_p_iDynTree__BerdySensor swig_types[26]
#define SWIGTYPE_p_iDynTree__BerdySparseMAPSolver swig_types[27]
#define SWIGTYPE_p_iDynTree__Box swig_types[28]
#define SWIGTYPE_p_iDynTree__ClassicalAcc swig_types[29]
#define SWIGTYPE_p_iDynTree__ColorViz swig_types[30]
#define SWIGTYPE_p_iDynTree__ContactWrench swig_types[31]
#define SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint swig_types[32]
#define SWIGTYPE_p_iDynTree__Cylinder swig_types[33]
#define SWIGTYPE_p_iDynTree__DOFSpatialForceArray swig_types[34]
#define SWIGTYPE_p_iDynTree__DOFSpatialMotionArray swig_types[35]
#define SWIGTYPE_p_iDynTree__Direction swig_types[36]
#define SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper swig_types[37]
#define SWIGTYPE_p_iDynTree__Dummy swig_types[38]
#define SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator swig_types[39]
#define SWIGTYPE_p_iDynTree__ExternalMesh swig_types[40]
#define SWIGTYPE_p_iDynTree__FixedJoint swig_types[41]
#define SWIGTYPE_p_iDynTree__FrameFreeFloatingJacobian swig_types[42]
#define SWIGTYPE_p_iDynTree__FreeFloatingAcc swig_types[43]
#define SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques swig_types[44]
#define SWIGTYPE_p_iDynTree__FreeFloatingMassMatrix swig_types[45]
#define SWIGTYPE_p_iDynTree__FreeFloatingPos swig_types[46]
#define SWIGTYPE_p_iDynTree__FreeFloatingVel swig_types[47]
#define SWIGTYPE_p_iDynTree__GeomVector3 swig_types[48]
#define SWIGTYPE_p_iDynTree__GyroscopeSensor swig_types[49]
#define SWIGTYPE_p_iDynTree__IAttitudeEstimator swig_types[50]
#define SWIGTYPE_p_iDynTree__ICamera swig_types[51]
#define SWIGTYPE_p_iDynTree__ICameraAnimator swig_types[52]
#define SWIGTYPE_p_iDynTree__IEnvironment swig_types[53]
#define SWIGTYPE_p_iDynTree__IFrameVisualization swig_types[54]
#define SWIGTYPE_p_iDynTree__IJetsVisualization swig_types[55]
#define SWIGTYPE_p_iDynTree__IJoint swig_types[56]
#define SWIGTYPE_p_iDynTree__ILight swig_types[57]
#define SWIGTYPE_p_iDynTree__IModelVisualization swig_types[58]
#define SWIGTYPE_p_iDynTree__ITexture swig_types[59]
#define SWIGTYPE_p_iDynTree__ITexturesHandler swig_types[60]
#define SWIGTYPE_p_iDynTree__IVectorsVisualization swig_types[61]
#define SWIGTYPE_p_iDynTree__IndexRange swig_types[62]
#define SWIGTYPE_p_iDynTree__InverseKinematics swig_types[63]
#define SWIGTYPE_p_iDynTree__JointDOFsDoubleArray swig_types[64]
#define SWIGTYPE_p_iDynTree__JointPosDoubleArray swig_types[65]
#define SWIGTYPE_p_iDynTree__JointSensor swig_types[66]
#define SWIGTYPE_p_iDynTree__KinDynComputations swig_types[67]
#define SWIGTYPE_p_iDynTree__Link swig_types[68]
#define SWIGTYPE_p_iDynTree__LinkAccArray swig_types[69]
#define SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias swig_types[70]
#define SWIGTYPE_p_iDynTree__LinkContactWrenches swig_types[71]
#define SWIGTYPE_p_iDynTree__LinkInertias swig_types[72]
#define SWIGTYPE_p_iDynTree__LinkPositions swig_types[73]
#define SWIGTYPE_p_iDynTree__LinkSensor swig_types[74]
#define SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts swig_types[75]
#define SWIGTYPE_p_iDynTree__LinkVelArray swig_types[76]
#define SWIGTYPE_p_iDynTree__LinkWrenches swig_types[77]
#define SWIGTYPE_p_iDynTree__Material swig_types[78]
#define SWIGTYPE_p_iDynTree__MatrixDynSize swig_types[79]
#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t swig_types[80]
#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t swig_types[81]
#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t swig_types[82]
#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t swig_types[83]
#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_4_t swig_types[84]
#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_3_t swig_types[85]
#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t swig_types[86]
#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t swig_types[87]
#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_1_t swig_types[88]
#define SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t swig_types[89]
#define SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t swig_types[90]
#define SWIGTYPE_p_iDynTree__MatrixViewT_double_t swig_types[91]
#define SWIGTYPE_p_iDynTree__Model swig_types[92]
#define SWIGTYPE_p_iDynTree__ModelCalibrationHelper swig_types[93]
#define SWIGTYPE_p_iDynTree__ModelExporter swig_types[94]
#define SWIGTYPE_p_iDynTree__ModelExporterOptions swig_types[95]
#define SWIGTYPE_p_iDynTree__ModelLoader swig_types[96]
#define SWIGTYPE_p_iDynTree__ModelParserOptions swig_types[97]
#define SWIGTYPE_p_iDynTree__ModelSolidShapes swig_types[98]
#define SWIGTYPE_p_iDynTree__MomentumFreeFloatingJacobian swig_types[99]
#define SWIGTYPE_p_iDynTree__MovableJointImplT_1_1_t swig_types[100]
#define SWIGTYPE_p_iDynTree__MovableJointImplT_2_2_t swig_types[101]
#define SWIGTYPE_p_iDynTree__MovableJointImplT_3_3_t swig_types[102]
#define SWIGTYPE_p_iDynTree__MovableJointImplT_4_4_t swig_types[103]
#define SWIGTYPE_p_iDynTree__MovableJointImplT_5_5_t swig_types[104]
#define SWIGTYPE_p_iDynTree__MovableJointImplT_6_6_t swig_types[105]
#define SWIGTYPE_p_iDynTree__Neighbor swig_types[106]
#define SWIGTYPE_p_iDynTree__PixelViz swig_types[107]
#define SWIGTYPE_p_iDynTree__Polygon swig_types[108]
#define SWIGTYPE_p_iDynTree__Polygon2D swig_types[109]
#define SWIGTYPE_p_iDynTree__Position swig_types[110]
#define SWIGTYPE_p_iDynTree__PositionRaw swig_types[111]
#define SWIGTYPE_p_iDynTree__PrismaticJoint swig_types[112]
#define SWIGTYPE_p_iDynTree__RevoluteJoint swig_types[113]
#define SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization swig_types[114]
#define SWIGTYPE_p_iDynTree__Rotation swig_types[115]
#define SWIGTYPE_p_iDynTree__RotationRaw swig_types[116]
#define SWIGTYPE_p_iDynTree__RotationalInertiaRaw swig_types[117]
#define SWIGTYPE_p_iDynTree__Sensor swig_types[118]
#define SWIGTYPE_p_iDynTree__SensorsList swig_types[119]
#define SWIGTYPE_p_iDynTree__SensorsMeasurements swig_types[120]
#define SWIGTYPE_p_iDynTree__SimpleLeggedOdometry swig_types[121]
#define SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor swig_types[122]
#define SWIGTYPE_p_iDynTree__SolidShape swig_types[123]
#define SWIGTYPE_p_iDynTree__SpanT_double__1_t swig_types[124]
#define SWIGTYPE_p_iDynTree__SpanT_double_const__1_t swig_types[125]
#define SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t swig_types[126]
#define SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t swig_types[127]
#define SWIGTYPE_p_iDynTree__SpatialAcc swig_types[128]
#define SWIGTYPE_p_iDynTree__SpatialForceVector swig_types[129]
#define SWIGTYPE_p_iDynTree__SpatialInertia swig_types[130]
#define SWIGTYPE_p_iDynTree__SpatialInertiaRaw swig_types[131]
#define SWIGTYPE_p_iDynTree__SpatialMomentum swig_types[132]
#define SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type swig_types[133]
#define SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type swig_types[134]
#define SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__AngularVector3Type swig_types[135]
#define SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__LinearVector3Type swig_types[136]
#define SWIGTYPE_p_iDynTree__SpatialMotionVector swig_types[137]
#define SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t swig_types[138]
#define SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t swig_types[139]
#define SWIGTYPE_p_iDynTree__Sphere swig_types[140]
#define SWIGTYPE_p_iDynTree__SubModelDecomposition swig_types[141]
#define SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor swig_types[142]
#define SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor swig_types[143]
#define SWIGTYPE_p_iDynTree__Transform swig_types[144]
#define SWIGTYPE_p_iDynTree__TransformDerivative swig_types[145]
#define SWIGTYPE_p_iDynTree__Traversal swig_types[146]
#define SWIGTYPE_p_iDynTree__Triplets swig_types[147]
#define SWIGTYPE_p_iDynTree__Twist swig_types[148]
#define SWIGTYPE_p_iDynTree__UnknownWrenchContact swig_types[149]
#define SWIGTYPE_p_iDynTree__VectorDynSize swig_types[150]
#define SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t swig_types[151]
#define SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t swig_types[152]
#define SWIGTYPE_p_iDynTree__VectorFixSizeT_2_t swig_types[153]
#define SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t swig_types[154]
#define SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t swig_types[155]
#define SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t swig_types[156]
#define SWIGTYPE_p_iDynTree__Visualizer swig_types[157]
#define SWIGTYPE_p_iDynTree__VisualizerOptions swig_types[158]
#define SWIGTYPE_p_iDynTree__Wrench swig_types[159]
#define SWIGTYPE_p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t swig_types[160]
#define SWIGTYPE_p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t swig_types[161]
#define SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers swig_types[162]
#define SWIGTYPE_p_index_type swig_types[163]
#define SWIGTYPE_p_iterator swig_types[164]
#define SWIGTYPE_p_pointer swig_types[165]
#define SWIGTYPE_p_reference swig_types[166]
#define SWIGTYPE_p_reverse_iterator swig_types[167]
#define SWIGTYPE_p_size_type swig_types[168]
#define SWIGTYPE_p_std__allocatorT_iDynTree__BerdyDynamicVariable_t swig_types[169]
#define SWIGTYPE_p_std__allocatorT_iDynTree__BerdySensor_t swig_types[170]
#define SWIGTYPE_p_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t swig_types[171]
#define SWIGTYPE_p_std__allocatorT_iDynTree__SolidShape_p_t swig_types[172]
#define SWIGTYPE_p_std__allocatorT_int_t swig_types[173]
#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[174]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t swig_types[175]
#define SWIGTYPE_p_std__ptrdiff_t swig_types[176]
#define SWIGTYPE_p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t_t swig_types[177]
#define SWIGTYPE_p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t_t swig_types[178]
#define SWIGTYPE_p_std__size_t swig_types[179]
#define SWIGTYPE_p_std__string swig_types[180]
#define SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t swig_types[181]
#define SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t swig_types[182]
#define SWIGTYPE_p_std__vectorT_iDynTree__MatrixDynSize_std__allocatorT_iDynTree__MatrixDynSize_t_t swig_types[183]
#define SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t swig_types[184]
#define SWIGTYPE_p_std__vectorT_iDynTree__PixelViz_std__allocatorT_iDynTree__PixelViz_t_t swig_types[185]
#define SWIGTYPE_p_std__vectorT_iDynTree__Polygon_std__allocatorT_iDynTree__Polygon_t_t swig_types[186]
#define SWIGTYPE_p_std__vectorT_iDynTree__Position_std__allocatorT_iDynTree__Position_t_t swig_types[187]
#define SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t swig_types[188]
#define SWIGTYPE_p_std__vectorT_iDynTree__Transform_std__allocatorT_iDynTree__Transform_t_t swig_types[189]
#define SWIGTYPE_p_std__vectorT_iDynTree__VectorDynSize_std__allocatorT_iDynTree__VectorDynSize_t_t swig_types[190]
#define SWIGTYPE_p_std__vectorT_iDynTree__VectorFixSizeT_2_t_std__allocatorT_iDynTree__VectorFixSizeT_2_t_t_t swig_types[191]
#define SWIGTYPE_p_std__vectorT_iDynTree__VectorFixSizeT_6_t_std__allocatorT_iDynTree__VectorFixSizeT_6_t_t_t swig_types[192]
#define SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t swig_types[193]
#define SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t swig_types[194]
#define SWIGTYPE_p_std__vectorT_std__ptrdiff_t_std__allocatorT_std__ptrdiff_t_t_t swig_types[195]
#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[196]
#define SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t swig_types[197]
#define SWIGTYPE_p_swig__MatlabSwigIterator swig_types[198]
#define SWIGTYPE_p_typed_iterator swig_types[199]
#define SWIGTYPE_p_unsigned_int swig_types[200]
#define SWIGTYPE_p_value_type swig_types[201]
static swig_type_info *swig_types[203];
static swig_module_info swig_module = {swig_types, 202, 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)

/* -------- TYPES TABLE (END) -------- */


#define SWIGVERSION 0x030011 
#define SWIG_VERSION SWIGVERSION


#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 


#include <stdexcept>


#include <string>


#include <iostream>


#include <stdexcept>


#if defined(__GNUC__)
#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
#     define SWIG_STD_NOMODERN_STL
#  endif
#endif


#include <stddef.h>

  
namespace swig {
  struct stop_iteration {
  };

  struct MatlabSwigIterator {
  private:
    mxArray* _seq;

  protected:
    MatlabSwigIterator(mxArray* seq) : _seq(seq)
    {
      (void)_seq;
    }
      
  public:
    virtual ~MatlabSwigIterator() {}

    virtual mxArray* value() const = 0;

    virtual MatlabSwigIterator *incr(size_t n = 1) = 0;

    virtual MatlabSwigIterator *decr(size_t n = 1)
    {
      throw stop_iteration();
    }

    virtual ptrdiff_t distance(const MatlabSwigIterator &x) const
    {
      throw std::invalid_argument("operation not supported");
    }

    virtual bool equal (const MatlabSwigIterator &x) const
    {
      throw std::invalid_argument("operation not supported");
    }
    
    virtual MatlabSwigIterator *copy() const = 0;

    mxArray* next()
    {
      mxArray* obj = value();
      incr();
      return obj;
    }

    mxArray* previous()
    {
      decr();
      return value();
    }

    MatlabSwigIterator *advance(ptrdiff_t n)
    {
      return  (n > 0) ?  incr(n) : decr(-n);
    }
      
    bool operator == (const MatlabSwigIterator& x)  const
    {
      return equal(x);
    }
      
    bool operator != (const MatlabSwigIterator& x) const
    {
      return ! operator==(x);
    }

    MatlabSwigIterator* operator ++ () {
      incr();
      return this;
    }

    MatlabSwigIterator* operator -- () {
      decr();
      return this;
    }
      
    MatlabSwigIterator* operator + (ptrdiff_t n) const
    {
      return copy()->advance(n);
    }

    MatlabSwigIterator* operator - (ptrdiff_t n) const
    {
      return copy()->advance(-n);
    }
      
    ptrdiff_t operator - (const MatlabSwigIterator& x) const
    {
      return x.distance(*this);
    }
      
    static swig_type_info* descriptor() {
      static int init = 0;
      static swig_type_info* desc = 0;
      if (!init) {
	desc = SWIG_TypeQuery("swig::MatlabSwigIterator *");
	init = 1;
      }	
      return desc;
    }    
  };
}


  SWIGINTERN int SWIG_AsVal_unsigned_SS_long (mxArray* pm, unsigned long* val)
    {
      if(mxGetNumberOfElements(pm)!=1) return SWIG_TypeError;
      switch(mxGetClassID(pm)){
      case mxINT8_CLASS:
        if(val) *val = (unsigned long)(*(int8_T*)mxGetData(pm)); break;
      case mxUINT8_CLASS:
        if(val) *val = (unsigned long)(*(uint8_T*)mxGetData(pm)); break;
      case mxINT16_CLASS:
        if(val) *val = (unsigned long)(*(int16_T*)mxGetData(pm)); break;
      case mxUINT16_CLASS:
        if(val) *val = (unsigned long)(*(uint16_T*)mxGetData(pm)); break;
      case mxINT32_CLASS:
        if(val) *val = (unsigned long)(*(int32_T*)mxGetData(pm)); break;
      case mxUINT32_CLASS:
        if(val) *val = (unsigned long)(*(uint32_T*)mxGetData(pm)); break;
      case mxINT64_CLASS:
        if(val) *val = (unsigned long)(*(int64_T*)mxGetData(pm)); break;
      case mxUINT64_CLASS: 
        if(val) *val = (unsigned long)(*(uint64_T*)mxGetData(pm)); break;
      case mxDOUBLE_CLASS:
      {
	double v=mxGetScalar(pm);
	if(v!=floor(v)) return SWIG_TypeError;
        if(val) *val = (unsigned long)v;
        break;
      }
      default: return SWIG_TypeError;
      }
      return SWIG_OK;
    }


  SWIGINTERN int SWIG_AsVal_unsigned_SS_long_SS_long (mxArray* pm, unsigned long long* val)
    {
      if(mxGetNumberOfElements(pm)!=1) return SWIG_TypeError;
      switch(mxGetClassID(pm)){
      case mxINT8_CLASS:
        if(val) *val = (unsigned long long)(*(int8_T*)mxGetData(pm)); break;
      case mxUINT8_CLASS:
        if(val) *val = (unsigned long long)(*(uint8_T*)mxGetData(pm)); break;
      case mxINT16_CLASS:
        if(val) *val = (unsigned long long)(*(int16_T*)mxGetData(pm)); break;
      case mxUINT16_CLASS:
        if(val) *val = (unsigned long long)(*(uint16_T*)mxGetData(pm)); break;
      case mxINT32_CLASS:
        if(val) *val = (unsigned long long)(*(int32_T*)mxGetData(pm)); break;
      case mxUINT32_CLASS:
        if(val) *val = (unsigned long long)(*(uint32_T*)mxGetData(pm)); break;
      case mxINT64_CLASS:
        if(val) *val = (unsigned long long)(*(int64_T*)mxGetData(pm)); break;
      case mxUINT64_CLASS: 
        if(val) *val = (unsigned long long)(*(uint64_T*)mxGetData(pm)); break;
      case mxDOUBLE_CLASS:
      {
	double v=mxGetScalar(pm);
	if(v!=floor(v)) return SWIG_TypeError;
        if(val) *val = (unsigned long long)v;
        break;
      }
      default: return SWIG_TypeError;
      }
      return SWIG_OK;
    }


SWIGINTERNINLINE int
SWIG_AsVal_size_t (mxArray* obj, size_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    unsigned long long v;
    res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  }
#endif
  return res;
}


  SWIGINTERNINLINE mxArray* SWIG_From_long    (long value)
    {    
      mxArray* out = mxCreateNumericMatrix(1,1,mxINT64_CLASS,mxREAL);
      *((int64_T*)mxGetData(out)) = (int64_T)value;
      return out;
    }


  SWIGINTERNINLINE mxArray* SWIG_From_long_SS_long    (long long value)
    {    
      mxArray* out = mxCreateNumericMatrix(1,1,mxINT64_CLASS,mxREAL);
      *((int64_T*)mxGetData(out)) = (int64_T)value;
      return out;
    }


SWIGINTERNINLINE mxArray*
SWIG_From_ptrdiff_t  (ptrdiff_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(ptrdiff_t) <= sizeof(long)) {
#endif
    return SWIG_From_long  (static_cast< long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(ptrdiff_t) <= sizeof(long long) */
    return SWIG_From_long_SS_long  (static_cast< long long >(value));
  }
#endif
}


SWIGINTERNINLINE mxArray*
  SWIG_From_bool  (bool value)
{
  return mxCreateLogicalScalar(value);
}


  SWIGINTERN int SWIG_AsVal_long (mxArray* pm, long* val)
    {
      if(mxGetNumberOfElements(pm)!=1) return SWIG_TypeError;
      switch(mxGetClassID(pm)){
      case mxINT8_CLASS:
        if(val) *val = (long)(*(int8_T*)mxGetData(pm)); break;
      case mxUINT8_CLASS:
        if(val) *val = (long)(*(uint8_T*)mxGetData(pm)); break;
      case mxINT16_CLASS:
        if(val) *val = (long)(*(int16_T*)mxGetData(pm)); break;
      case mxUINT16_CLASS:
        if(val) *val = (long)(*(uint16_T*)mxGetData(pm)); break;
      case mxINT32_CLASS:
        if(val) *val = (long)(*(int32_T*)mxGetData(pm)); break;
      case mxUINT32_CLASS:
        if(val) *val = (long)(*(uint32_T*)mxGetData(pm)); break;
      case mxINT64_CLASS:
        if(val) *val = (long)(*(int64_T*)mxGetData(pm)); break;
      case mxUINT64_CLASS: 
        if(val) *val = (long)(*(uint64_T*)mxGetData(pm)); break;
      case mxDOUBLE_CLASS:
      {
	double v=mxGetScalar(pm);
	if(v!=floor(v)) return SWIG_TypeError;
        if(val) *val = (long)v;
        break;
      }
      default: return SWIG_TypeError;
      }
      return SWIG_OK;
    }


  SWIGINTERN int SWIG_AsVal_long_SS_long (mxArray* pm, long long* val)
    {
      if(mxGetNumberOfElements(pm)!=1) return SWIG_TypeError;
      switch(mxGetClassID(pm)){
      case mxINT8_CLASS:
        if(val) *val = (long long)(*(int8_T*)mxGetData(pm)); break;
      case mxUINT8_CLASS:
        if(val) *val = (long long)(*(uint8_T*)mxGetData(pm)); break;
      case mxINT16_CLASS:
        if(val) *val = (long long)(*(int16_T*)mxGetData(pm)); break;
      case mxUINT16_CLASS:
        if(val) *val = (long long)(*(uint16_T*)mxGetData(pm)); break;
      case mxINT32_CLASS:
        if(val) *val = (long long)(*(int32_T*)mxGetData(pm)); break;
      case mxUINT32_CLASS:
        if(val) *val = (long long)(*(uint32_T*)mxGetData(pm)); break;
      case mxINT64_CLASS:
        if(val) *val = (long long)(*(int64_T*)mxGetData(pm)); break;
      case mxUINT64_CLASS: 
        if(val) *val = (long long)(*(uint64_T*)mxGetData(pm)); break;
      case mxDOUBLE_CLASS:
      {
	double v=mxGetScalar(pm);
	if(v!=floor(v)) return SWIG_TypeError;
        if(val) *val = (long long)v;
        break;
      }
      default: return SWIG_TypeError;
      }
      return SWIG_OK;
    }


SWIGINTERNINLINE int
SWIG_AsVal_ptrdiff_t (mxArray* obj, ptrdiff_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(ptrdiff_t) <= sizeof(long)) {
#endif
    long v;
    res = SWIG_AsVal_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(ptrdiff_t) <= sizeof(long long)) {
    long long v;
    res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
  }
#endif
  return res;
}


#include <algorithm>


#include <vector>


namespace swig {
  template <class Type>
  struct noconst_traits {
    typedef Type noconst_type;
  };

  template <class Type>
  struct noconst_traits<const Type> {
    typedef Type noconst_type;
  };

  /*
    type categories
  */
  struct pointer_category { };
  struct value_category { };

  /*
    General traits that provides type_name and type_info
  */
  template <class Type> struct traits { };

  template <class Type>
  inline const char* type_name() {
    return traits<typename noconst_traits<Type >::noconst_type >::type_name();
  }

  template <class Type>
  struct traits_info {
    static swig_type_info *type_query(std::string name) {
      name += " *";
      return SWIG_TypeQuery(name.c_str());
    }
    static swig_type_info *type_info() {
      static swig_type_info *info = type_query(type_name<Type>());
      return info;
    }
  };

  template <class Type>
  inline swig_type_info *type_info() {
    return traits_info<Type>::type_info();
  }

  /*
    Partial specialization for pointers
  */
  template <class Type> struct traits <Type *> {
    typedef pointer_category category;
    static std::string make_ptr_name(const char* name) {
      std::string ptrname = name;
      ptrname += " *";
      return ptrname;
    }
    static const char* type_name() {
      static std::string name = make_ptr_name(swig::type_name<Type>());
      return name.c_str();
    }
  };

  template <class Type, class Category>
  struct traits_as { };

  template <class Type, class Category>
  struct traits_check { };

}


namespace swig {  
// Traits that provides the from method
  template <class Type> struct traits_from_ptr {
    static mxArray* from(Type *val, int owner = 0) {
      return SWIG_NewPointerObj(val, type_info<Type>(), owner);
    }
  };

  template <class Type> struct traits_from {
    static mxArray* from(const Type& val) {
      return traits_from_ptr<Type>::from(new Type(val), 1);
    }
  };

  template <class Type> struct traits_from<Type *> {
    static mxArray* from(Type* val) {
      return traits_from_ptr<Type>::from(val, 0);
    }
  };

  template <class Type> struct traits_from<const Type *> {
    static mxArray* from(const Type* val) {
      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
    }
  };


  template <class Type>
  inline mxArray* from(const Type& val) {
    return traits_from<Type>::from(val);
  }

  template <class Type>
  inline mxArray* from_ptr(Type* val, int owner) {
    return traits_from_ptr<Type>::from(val, owner);
  }

    // Traits that provides the asval/as/check method
  template <class Type>
  struct traits_asptr {   
    static int asptr(mxArray* pm, Type **val) {
      Type *p;
      int res = SWIG_ConvertPtr(pm, (void**)&p, type_info<Type>(), 0);
      if (SWIG_IsOK(res)) {
	if (val) *val = p;
      }
      return res;
    }
  }; 

  template <class Type>
  inline int asptr(mxArray* pm, Type **vptr) {
    return traits_asptr<Type>::asptr(pm, vptr);
  }

  template <class Type> 
  struct traits_asval {
    static int asval(mxArray* pm, Type *val) {
      if (val) {
	Type *p = 0;
	int res = traits_asptr<Type>::asptr(pm, &p);
	if (!SWIG_IsOK(res)) return res;	
	if (p) {
	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
	  *(const_cast<noconst_type*>(val)) = *p;
	  if (SWIG_IsNewObj(res)){
	    delete p;
	    res = SWIG_DelNewMask(res);
	  }
	  return res;
	} else {
	  return SWIG_ERROR;
	}
      } else {
	return traits_asptr<Type>::asptr(pm, (Type **)(0));
      }
    }
  };

  template <class Type> struct traits_asval<Type*> {
    static int asval(mxArray* pm, Type **val) {
      if (val) {
        typedef typename noconst_traits<Type>::noconst_type noconst_type;
        noconst_type *p = 0;
        int res = traits_asptr<noconst_type>::asptr(pm,  &p);
        if (SWIG_IsOK(res)) {
          *(const_cast<noconst_type**>(val)) = p;
	}
	return res;
      } else {
	return traits_asptr<Type>::asptr(pm, (Type **)(0));
      }
    }
  };
  
  template <class Type>
  inline int asval(mxArray* pm, Type *val) {
    return traits_asval<Type>::asval(pm, val);
  }

  template <class Type> 
  struct traits_as<Type, value_category> {
    static Type as(mxArray* pm, bool throw_error) {
      Type v;
      int res = asval(pm, &v);
      if (mxGetClassID(pm) == mxUNKNOWN_CLASS || !SWIG_IsOK(res)) {
	if (!Matlab_Error_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	if (throw_error) throw std::invalid_argument("bad type");
      }
      return v;
    }
  };

  template <class Type> 
  struct traits_as<Type, pointer_category> {
    static Type as(mxArray* pm, bool throw_error) {
      Type *v = 0;      
      int res = traits_asptr<Type>::asptr(pm, &v);
      if (SWIG_IsOK(res) && v) {
	if (SWIG_IsNewObj(res)) {
	  Type r(*v);
	  delete v;
	  return r;
	} else {
	  return *v;
	}
      } else {
	// Uninitialized return value, no Type() constructor required.
	static Type *v_def = (Type*) malloc(sizeof(Type));
	if (!Matlab_Error_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	if (throw_error) throw std::invalid_argument("bad type");
        memset(static_cast<void *>(v_def),0,sizeof(Type));
	return *v_def;
      }
    }
  };

  template <class Type> 
  struct traits_as<Type*, pointer_category> {
    static Type* as(mxArray* pm, bool throw_error) {
      Type *v = 0;      
      int res = traits_asptr<Type>::asptr(pm, &v);
      if (SWIG_IsOK(res)) {
	return v;
      } else {
	if (!Matlab_Error_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	if (throw_error) throw std::invalid_argument("bad type");
	return 0;
      }
    }
  };
    
  template <class Type>
  inline Type as(mxArray* pm, bool te = false) {
    return traits_as<Type, typename traits<Type>::category>::as(pm, te);
  }

  template <class Type> 
  struct traits_check<Type, value_category> {
    static bool check(mxArray* obj) {
      int res = asval(obj, (Type *)(0));
      return SWIG_IsOK(res) ? true : false;
    }
  };

  template <class Type> 
  struct traits_check<Type, pointer_category> {
    static bool check(mxArray* obj) {
      int res = asptr(obj, (Type **)(0));
      return SWIG_IsOK(res) ? true : false;
    }
  };

  template <class Type>
  inline bool check(mxArray* obj) {
    return traits_check<Type, typename traits<Type>::category>::check(obj);
  }
}


#include <functional>

namespace std {













}

namespace swig {
  inline size_t
  check_index(ptrdiff_t i, size_t size, bool insert = false) {
    if ( i < 0 ) {
      if ((size_t) (-i) <= size)
	return (size_t) (i + size);
    } else if ( (size_t) i < size ) {
      return (size_t) i;
    } else if (insert && ((size_t) i == size)) {
      return size;
    }

    throw std::out_of_range("index out of range");
  }

  inline size_t
  slice_index(ptrdiff_t i, size_t size) {
    if ( i < 0 ) {
      if ((size_t) (-i) <= size) {
	return (size_t) (i + size);
      } else {
	throw std::out_of_range("index out of range");
      }
    } else {
      return ( (size_t) i < size ) ? ((size_t) i) : size;
    }
  }

  template <class Sequence, class Difference>
  inline typename Sequence::iterator
  getpos(Sequence* self, Difference i)  {
    typename Sequence::iterator pos = self->begin();
    std::advance(pos, check_index(i,self->size()));
    return pos;
  }

  template <class Sequence, class Difference>
  inline typename Sequence::const_iterator
  cgetpos(const Sequence* self, Difference i)  {
    typename Sequence::const_iterator pos = self->begin();
    std::advance(pos, check_index(i,self->size()));
    return pos;
  }

  template <class Sequence, class Difference>
  inline Sequence*
  getslice(const Sequence* self, Difference i, Difference j) {
    typename Sequence::size_type size = self->size();
    typename Sequence::size_type ii = swig::check_index(i, size);
    typename Sequence::size_type jj = swig::slice_index(j, size);

    if (jj > ii) {
      typename Sequence::const_iterator vb = self->begin();
      typename Sequence::const_iterator ve = self->begin();
      std::advance(vb,ii);
      std::advance(ve,jj);
      return new Sequence(vb, ve);
    } else {
      return new Sequence();
    }
  }

  template <class Sequence, class Difference, class InputSeq>
  inline void
  setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
    typename Sequence::size_type size = self->size();
    typename Sequence::size_type ii = swig::check_index(i, size, true);
    typename Sequence::size_type jj = swig::slice_index(j, size);
    if (jj < ii) jj = ii;
    size_t ssize = jj - ii;
    if (ssize <= v.size()) {
      typename Sequence::iterator sb = self->begin();
      typename InputSeq::const_iterator vmid = v.begin();
      std::advance(sb,ii);
      std::advance(vmid, jj - ii);
      self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
    } else {
      typename Sequence::iterator sb = self->begin();
      typename Sequence::iterator se = self->begin();
      std::advance(sb,ii);
      std::advance(se,jj);
      self->erase(sb,se);
      sb = self->begin();
      std::advance(sb,ii);
      self->insert(sb, v.begin(), v.end());
    }
  }

  template <class Sequence, class Difference>
  inline void
  delslice(Sequence* self, Difference i, Difference j) {
    typename Sequence::size_type size = self->size();
    typename Sequence::size_type ii = swig::check_index(i, size, true);
    typename Sequence::size_type jj = swig::slice_index(j, size);
    if (jj > ii) {
      typename Sequence::iterator sb = self->begin();
      typename Sequence::iterator se = self->begin();
      std::advance(sb,ii);
      std::advance(se,jj);
      self->erase(sb,se);
    }
  }
}


#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
#  if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
#    define SWIG_STD_NOITERATOR_TRAITS_STL
#  endif
#endif

#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
#include <iterator>
#else
namespace std {
  template <class Iterator>
  struct iterator_traits {
    typedef ptrdiff_t difference_type;
    typedef typename Iterator::value_type value_type;
  };

  template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
  struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
    typedef Distance difference_type;
    typedef T value_type;
  };

  template <class T>
  struct iterator_traits<T*> {
    typedef T value_type;
    typedef ptrdiff_t difference_type;
  };

  template<typename _InputIterator>
  inline typename iterator_traits<_InputIterator>::difference_type
  distance(_InputIterator __first, _InputIterator __last)
  {
    typename iterator_traits<_InputIterator>::difference_type __n = 0;
    while (__first != __last) {
      ++__first; ++__n;
    }
    return __n;
  }
}
#endif


namespace swig {
  template<typename OutIterator>
  class MatlabSwigIterator_T :  public MatlabSwigIterator
  {
  public:
    typedef OutIterator out_iterator;
    typedef typename std::iterator_traits<out_iterator>::value_type value_type;    
    typedef MatlabSwigIterator_T<out_iterator> self_type;

    MatlabSwigIterator_T(out_iterator curr, mxArray* seq)
      : MatlabSwigIterator(seq), current(curr)
    {
    }

    const out_iterator& get_current() const
    {
      return current;
    }

    
    bool equal (const MatlabSwigIterator &iter) const
    {
      const self_type *iters = dynamic_cast<const self_type *>(&iter);
      if (iters) {
	return (current == iters->get_current());
      } else {
	throw std::invalid_argument("bad iterator type");
      }
    }
    
    ptrdiff_t distance(const MatlabSwigIterator &iter) const
    {
      const self_type *iters = dynamic_cast<const self_type *>(&iter);
      if (iters) {
	return std::distance(current, iters->get_current());
      } else {
	throw std::invalid_argument("bad iterator type");
      }
    }    
    
  protected:
    out_iterator current;
  };
  
  template <class ValueType>
  struct from_oper 
  {
    typedef const ValueType& argument_type;
    typedef mxArray* result_type;
    result_type operator()(argument_type v) const
    {
      return swig::from(v);
    }
  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class MatlabSwigIteratorOpen_T :  public MatlabSwigIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef MatlabSwigIterator_T<out_iterator>  base;
    typedef MatlabSwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
    
    MatlabSwigIteratorOpen_T(out_iterator curr, mxArray* seq)
      : MatlabSwigIterator_T<OutIterator>(curr, seq)
    {
    }
    
    mxArray* value() const {
      return from(static_cast<const value_type&>(*(base::current)));
    }
    
    MatlabSwigIterator *copy() const
    {
      return new self_type(*this);
    }

    MatlabSwigIterator *incr(size_t n = 1)
    {
      while (n--) {
	++base::current;
      }
      return this;
    }

    MatlabSwigIterator *decr(size_t n = 1)
    {
      while (n--) {
	--base::current;
      }
      return this;
    }
  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class MatlabSwigIteratorClosed_T :  public MatlabSwigIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef MatlabSwigIterator_T<out_iterator>  base;    
    typedef MatlabSwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
    
    MatlabSwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, mxArray* seq)
      : MatlabSwigIterator_T<OutIterator>(curr, seq), begin(first), end(last)
    {
    }
    
    mxArray* value() const {
      if (base::current == end) {
	throw stop_iteration();
      } else {
	return from(static_cast<const value_type&>(*(base::current)));
      }
    }
    
    MatlabSwigIterator *copy() const
    {
      return new self_type(*this);
    }

    MatlabSwigIterator *incr(size_t n = 1)
    {
      while (n--) {
	if (base::current == end) {
	  throw stop_iteration();
	} else {
	  ++base::current;
	}
      }
      return this;
    }

    MatlabSwigIterator *decr(size_t n = 1)
    {
      while (n--) {
	if (base::current == begin) {
	  throw stop_iteration();
	} else {
	  --base::current;
	}
      }
      return this;
    }

  private:
    out_iterator begin;
    out_iterator end;
  };

  template<typename OutIter>
  inline MatlabSwigIterator*
  make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, mxArray* seq = 0 /* KT mxArray()*/)
  {
    return new MatlabSwigIteratorClosed_T<OutIter>(current, begin, end, seq);
  }

  template<typename OutIter>
  inline MatlabSwigIterator*
  make_output_iterator(const OutIter& current, mxArray* seq = 0 /* KT mxArray()*/)
  {
    return new MatlabSwigIteratorOpen_T<OutIter>(current, seq);
  }
}


namespace swig
{
  template <class T>
    struct MatlabSequence_Ref // * matlab can't support these, because of how assignment works
  {
    MatlabSequence_Ref(mxArray* const seq, int index)
      : _seq(seq), _index(index)
    {
    }

    operator T () const
    {
      //      swig::SwigVar_PyObject item = MatlabSequence_GetItem(_seq, _index);
      mxArray* item; // * todo
      try {
	return swig::as<T>(item, true);
      } catch (std::exception& e) {
	char msg[1024];
	sprintf(msg, "in sequence element %d ", _index);
	if (!Matlab_Error_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
	}
	SWIG_Matlab_AddErrorMsg(msg);
	SWIG_Matlab_AddErrorMsg(e.what());
	throw;
      }
    }

    MatlabSequence_Ref& operator=(const T& v)
    {
      //      MatlabSequence_SetItem(_seq, _index, swig::from<T>(v));
      // * todo
      return *this;
    }

  private:
    mxArray* _seq;
    int _index;
  };

  template <class T>
  struct MatlabSequence_ArrowProxy
  {
    MatlabSequence_ArrowProxy(const T& x): m_value(x) {}
    const T* operator->() const { return &m_value; }
    operator const T*() const { return &m_value; }
    T m_value;
  };

  template <class T, class Reference >
  struct MatlabSequence_InputIterator
  {
    typedef MatlabSequence_InputIterator<T, Reference > self;

    typedef std::random_access_iterator_tag iterator_category;
    typedef Reference reference;
    typedef T value_type;
    typedef T* pointer;
    typedef int difference_type;

    MatlabSequence_InputIterator()
    {
    }

    MatlabSequence_InputIterator(mxArray* const seq, int index)
      : _seq(seq), _index(index)
    {
    }

    reference operator*() const
    {
      return reference(_seq, _index);
    }

    MatlabSequence_ArrowProxy<T>
    operator->() const {
      return MatlabSequence_ArrowProxy<T>(operator*());
    }

    bool operator==(const self& ri) const
    {
      return (_index == ri._index);
    }

    bool operator!=(const self& ri) const
    {
      return !(operator==(ri));
    }

    self& operator ++ ()
    {
      ++_index;
      return *this;
    }

    self& operator -- ()
    {
      --_index;
      return *this;
    }

    self& operator += (difference_type n)
    {
      _index += n;
      return *this;
    }

    self operator +(difference_type n) const
    {
      return self(_seq, _index + n);
    }

    self& operator -= (difference_type n)
    {
      _index -= n;
      return *this;
    }

    self operator -(difference_type n) const
    {
      return self(_seq, _index - n);
    }

    difference_type operator - (const self& ri) const
    {
      return _index - ri._index;
    }

    bool operator < (const self& ri) const
    {
      return _index < ri._index;
    }

    reference
    operator[](difference_type n) const
    {
      return reference(_seq, _index + n);
    }

  private:
    mxArray* _seq;
    difference_type _index;
  };

  template <class T>
  struct MatlabSequence_Cont
  {
    typedef MatlabSequence_Ref<T> reference;
    typedef const MatlabSequence_Ref<T> const_reference;
    typedef T value_type;
    typedef T* pointer;
    typedef int difference_type;
    typedef int size_type;
    typedef const pointer const_pointer;
    typedef MatlabSequence_InputIterator<T, reference> iterator;
    typedef MatlabSequence_InputIterator<T, const_reference> const_iterator;

    MatlabSequence_Cont(mxArray* const seq) : _seq(seq)
    {
      // * assert that we have map type etc.
      /*
      if (!MatlabSequence_Check(seq)) {
	throw std::invalid_argument("a sequence is expected");
      }
      _seq = seq;
      Py_INCREF(_seq);
      */
    }

    ~MatlabSequence_Cont()
    {
    }

    size_type size() const
    {
      //      return static_cast<size_type>(MatlabSequence_Size(_seq));
      return 0; // * todo
    }

    bool empty() const
    {
      return size() == 0;
    }

    iterator begin()
    {
      return iterator(_seq, 0);
    }

    const_iterator begin() const
    {
      return const_iterator(_seq, 0);
    }

    iterator end()
    {
      return iterator(_seq, size());
    }

    const_iterator end() const
    {
      return const_iterator(_seq, size());
    }

    reference operator[](difference_type n)
    {
      return reference(_seq, n);
    }

    const_reference operator[](difference_type n)  const
    {
      return const_reference(_seq, n);
    }

    bool check(bool set_err = true) const
    {
      int s = size();
      for (int i = 0; i < s; ++i) {
	//	swig::SwigVar_PyObject item = MatlabSequence_GetItem(_seq, i);
	mxArray* item; // * todo
	if (!swig::check<value_type>(item)) {
	  if (set_err) {
	    char msg[1024];
	    sprintf(msg, "in sequence element %d", i);
	    SWIG_Error(SWIG_RuntimeError, msg);
	  }
	  return false;
	}
      }
      return true;
    }

  private:
    mxArray* _seq;
  };

}


SWIGINTERN int
SWIG_AsCharPtrAndSize(mxArray* pm, char** cptr, size_t* psize, int *alloc)
{
  if(!mxIsChar(pm) || (mxGetNumberOfElements(pm) != 0 && mxGetM(pm)!=1)) return SWIG_TypeError;
  size_t len=mxGetN(pm);
  static char buf[256];
  int flag = mxGetString(pm,buf,(mwSize)sizeof(buf));
  if(flag) return SWIG_TypeError;

  if (alloc) {
    *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), buf, sizeof(char)*(len + 1)));
    *alloc = SWIG_NEWOBJ;
  } else if (cptr)
    *cptr = buf;
  if (psize)
    *psize = len + 1;
  return SWIG_OK;
}


SWIGINTERN int
SWIG_AsPtr_std_string (mxArray* obj, std::string **val) 
{
  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
    if (buf) {
      if (val) *val = new std::string(buf, size - 1);
      if (alloc == SWIG_NEWOBJ) delete[] buf;
      return SWIG_NEWOBJ;
    } else {
      if (val) *val = 0;
      return SWIG_OLDOBJ;
    }
  } else {
    static int init = 0;
    static swig_type_info* descriptor = 0;
    if (!init) {
      descriptor = SWIG_TypeQuery("std::string" " *");
      init = 1;
    }
    if (descriptor) {
      std::string *vptr;
      int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
      if (SWIG_IsOK(res) && val) *val = vptr;
      return res;
    }
  }
  return SWIG_ERROR;
}


SWIGINTERN int
SWIG_AsVal_std_string (mxArray* obj, std::string *val)
{
  std::string* v = (std::string *) 0;
  int res = SWIG_AsPtr_std_string (obj, &v);
  if (!SWIG_IsOK(res)) return res;
  if (v) {
    if (val) *val = *v;
    if (SWIG_IsNewObj(res)) {
      delete v;
      res = SWIG_DelNewMask(res);
    }
    return res;
  }
  return SWIG_ERROR;
}


SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static int init = 0;
  static swig_type_info* info = 0;
  if (!init) {
    info = SWIG_TypeQuery("_p_char");
    init = 1;
  }
  return info;
}


SWIGINTERNINLINE mxArray*
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
   mwSize dims[2] = {1,(mwSize)size};
   mxArray* ret = mxCreateCharArray((mwSize)2,dims);
   if(!ret) mexErrMsgIdAndTxt("SWIG:FromCharPtrAndSize","mxCreateCharArray failed");
   mxChar *ret_data = (mxChar *)mxGetData(ret);
   size_t i;
   for(i=0; i<size; ++i) ret_data[i] = carray[i];
   return ret;  
}


SWIGINTERNINLINE mxArray*
SWIG_From_std_string  (const std::string& s)
{
  return SWIG_FromCharPtrAndSize(s.data(), s.size());
}


namespace swig {
  template <> struct traits<std::string > {
    typedef value_category category;
    static const char* type_name() { return"std::string"; }
  };  
  template <>  struct traits_asval<std::string > {   
    typedef std::string value_type;
    static int asval(mxArray* obj, value_type *val) { 
      return SWIG_AsVal_std_string (obj, val);
    }
  };
  template <>  struct traits_from<std::string > {
    typedef std::string value_type;
    static mxArray* from(const value_type& val) {
      return SWIG_From_std_string  (val);
    }
  };
}


namespace swig {
  template <class Matlabseq, class Seq>
  inline void
  assign(const Matlabseq& matlabseq, Seq* seq) {
#ifdef SWIG_STD_NOASSIGN_STL
    typedef typename Matlabseq::value_type value_type;
    typename Matlabseq::const_iterator it = matlabseq.begin();
    for (;it != matlabseq.end(); ++it) {
      seq->insert(seq->end(),(value_type)(*it));
    }
#else
    seq->assign(matlabseq.begin(), matlabseq.end());
#endif
  }

  template <class Seq, class T = typename Seq::value_type >
  struct traits_asptr_stdseq {
    typedef Seq sequence;
    typedef T value_type;
    typedef typename sequence::iterator iterator;

    static int asptr(mxArray* obj, sequence **seq) {
      if (obj && mxGetClassID(obj)==mxCELL_CLASS &&
              mxGetNumberOfDimensions(obj)==2 &&
              mxGetM(obj)==1 && mxGetN(obj)>0 ) {
        // Convert to cell array.
        if (seq) {
          *seq = new sequence();
          int N = mxGetN(obj);
          for (int i=0; i<N; ++i) {
            (*seq)->push_back(swig::as<value_type>(mxGetCell(obj, i)));
          }
          return SWIG_NEWOBJ;
        }
      } 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;
    }
  };

  template <class Seq, class T = typename Seq::value_type >
  struct traits_from_stdseq {
    typedef Seq sequence;
    typedef T value_type;
    typedef typename Seq::size_type size_type;
    typedef typename sequence::const_iterator const_iterator;

    static mxArray* from(const sequence& seq) {







      size_type size = seq.size();
      if (size <= (size_type)INT_MAX) {
        mxArray* c = mxCreateCellMatrix(1,size);
	int i = 0;
	for (const_iterator it = seq.begin();
	     it != seq.end(); ++it, ++i) {
	  mxSetCell(c, i, swig::from<value_type>(*it));
	}
	return c;
      } else {
	SWIG_Error(SWIG_RuntimeError, "swig overflow error: sequence size not valid in matlab");
	return 0;
      }
      return 0;
    }
  };
}


  namespace swig {
    template <class T>
    struct traits_asptr<std::vector<T> >  {
      static int asptr(mxArray* obj, std::vector<T> **vec) {
	return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
      }
    };
    
    template <class T>
    struct traits_from<std::vector<T> > {
      static mxArray* from(const std::vector<T>& vec) {
	return traits_from_stdseq<std::vector<T> >::from(vec);
      }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< std::string, std::allocator< std::string > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::string" "," "std::allocator< std::string >" " >";
	  }
	};
      }
    
SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::string,std::allocator< std::string > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__brace(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_string_Sg__setbrace(std::vector< std::string > *self,std::vector< std::string >::value_type x,std::vector< std::string >::difference_type i){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN void std_vector_Sl_std_string_Sg__append(std::vector< std::string > *self,std::vector< std::string >::value_type x){
      self->push_back(x);
    }

  SWIGINTERNINLINE mxArray* SWIG_From_unsigned_SS_long    (unsigned long value)
    {    
      mxArray* out = mxCreateNumericMatrix(1,1,mxUINT64_CLASS,mxREAL);
      *((uint64_T*)mxGetData(out)) = (uint64_T)value;
      return out;
    }


  SWIGINTERNINLINE mxArray* SWIG_From_unsigned_SS_long_SS_long    (unsigned long long value)
    {    
      mxArray* out = mxCreateNumericMatrix(1,1,mxUINT64_CLASS,mxREAL);
      *((uint64_T*)mxGetData(out)) = (uint64_T)value;
      return out;
    }


SWIGINTERNINLINE mxArray*
SWIG_From_size_t  (size_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(size_t) <= sizeof(unsigned long long) */
    return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
  }
#endif
}

SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator first,std::vector< std::string >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__insert__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_string_Sg__insert__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::size_type n,std::vector< std::string >::value_type const &x){ self->insert(pos, n, x); }

#include <limits.h>
#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


SWIGINTERN int
SWIG_AsVal_int (mxArray* obj, int *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < INT_MIN || v > INT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< int >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE mxArray*
SWIG_From_int  (int value)
{    
  return SWIG_From_long  (value);
}


namespace swig {
  template <> struct traits<int > {
    typedef value_category category;
    static const char* type_name() { return"int"; }
  };  
  template <>  struct traits_asval<int > {   
    typedef int value_type;
    static int asval(mxArray* obj, value_type *val) { 
      return SWIG_AsVal_int (obj, val);
    }
  };
  template <>  struct traits_from<int > {
    typedef int value_type;
    static mxArray* from(const value_type& val) {
      return SWIG_From_int  (val);
    }
  };
}


      namespace swig {
	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 >" " >";
	  }
	};
      }
    
SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< int,std::allocator< int > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__brace(std::vector< int > *self,std::vector< int >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_int_Sg__setbrace(std::vector< int > *self,std::vector< int >::value_type x,std::vector< int >::difference_type i){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type x){
      self->push_back(x);
    }
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_1(std::vector< int > *self,std::vector< int >::iterator first,std::vector< int >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__insert__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::size_type n,std::vector< int >::value_type const &x){ self->insert(pos, n, x); }

/* Note : always include headers following the inheritance order */
#include <cmath>

//Utils
#include "iDynTree/Core/Utils.h"

// Basic math classes
#include "iDynTree/Core/MatrixDynSize.h"
#include "iDynTree/Core/MatrixFixSize.h"
#include "iDynTree/Core/SparseMatrix.h"

#include "iDynTree/Core/VectorDynSize.h"
#include "iDynTree/Core/VectorFixSize.h"

// Basic Vectors: Point Vectors and Spatial Vectors
#include "iDynTree/Core/PositionRaw.h"
#include "iDynTree/Core/Position.h"
#include "iDynTree/Core/SpatialForceVector.h"
#include "iDynTree/Core/SpatialMotionVector.h"
#include "iDynTree/Core/Twist.h"
#include "iDynTree/Core/Wrench.h"
#include "iDynTree/Core/SpatialMomentum.h"
#include "iDynTree/Core/SpatialAcc.h"
#include "iDynTree/Core/ClassicalAcc.h"
#include "iDynTree/Core/Direction.h"
#include "iDynTree/Core/Axis.h"

// Inertias
#include "iDynTree/Core/RotationalInertiaRaw.h"
#include "iDynTree/Core/SpatialInertiaRaw.h"
#include "iDynTree/Core/SpatialInertia.h"
#include "iDynTree/Core/ArticulatedBodyInertia.h"
#include "iDynTree/Core/InertiaNonLinearParametrization.h"

// Transformations: Rotation and Transform
#include "iDynTree/Core/RotationRaw.h"
#include "iDynTree/Core/Rotation.h"
#include "iDynTree/Core/Transform.h"
#include "iDynTree/Core/TransformDerivative.h"
#include "iDynTree/Core/Span.h"

// Model related data structures
#include "iDynTree/Model/Indices.h"
#include "iDynTree/Model/LinkState.h"
#include "iDynTree/Model/Link.h"
#include "iDynTree/Model/IJoint.h"
#include "iDynTree/Model/FixedJoint.h"
#include "iDynTree/Model/MovableJointImpl.h"
#include "iDynTree/Model/RevoluteJoint.h"
#include "iDynTree/Model/PrismaticJoint.h"
#include "iDynTree/Model/Traversal.h"
#include "iDynTree/Model/SolidShapes.h"
#include "iDynTree/Model/Model.h"
#include "iDynTree/Model/JointState.h"
#include "iDynTree/Model/FreeFloatingMatrices.h"
#include "iDynTree/Model/FreeFloatingState.h"
#include "iDynTree/Model/ContactWrench.h"

// Kinematics & Dynamics related functions
#include "iDynTree/Model/ForwardKinematics.h"
#include "iDynTree/Model/Dynamics.h"

// Sensors related data structures
#include "iDynTree/Sensors/Sensors.h"
#include "iDynTree/Sensors/SixAxisForceTorqueSensor.h"
#include "iDynTree/Sensors/AccelerometerSensor.h"
#include "iDynTree/Sensors/GyroscopeSensor.h"
#include "iDynTree/Sensors/ThreeAxisAngularAccelerometerSensor.h"
#include "iDynTree/Sensors/ThreeAxisForceTorqueContactSensor.h"
#include "iDynTree/Sensors/PredictSensorsMeasurements.h"

// Model loading from external formats
#include "iDynTree/ModelIO/URDFDofsImport.h"
#include "iDynTree/ModelIO/ModelLoader.h"
#include "iDynTree/ModelIO/ModelExporter.h"
#include "iDynTree/ModelIO/ModelCalibrationHelper.h"


// Estimation related classes
#include "iDynTree/Estimation/ExternalWrenchesEstimation.h"
#include "iDynTree/Estimation/ExtWrenchesAndJointTorquesEstimator.h"
#include "iDynTree/Estimation/SimpleLeggedOdometry.h"
#include "iDynTree/Estimation/BerdyHelper.h"
#include "iDynTree/Estimation/BerdySparseMAPSolver.h"
#include "iDynTree/Estimation/AttitudeEstimator.h"
#include "iDynTree/Estimation/AttitudeMahonyFilter.h"
#include "iDynTree/Estimation/ExtendedKalmanFilter.h"
#include "iDynTree/Estimation/AttitudeQuaternionEKF.h"

// SolidShapes related classes
#include "iDynTree/InertialParametersSolidShapesHelpers.h"

// High level interfaces
#include "iDynTree/KinDynComputations.h"

// Visualization
#include "iDynTree/Visualizer.h"

// Inverse Kinematics
#include "iDynTree/ConvexHullHelpers.h"
#include "iDynTree/InverseKinematics.h"



  namespace swig {
    template <>  struct traits< iDynTree::BerdySensor > {
      typedef pointer_category category;
      static const char* type_name() { return"iDynTree::BerdySensor"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< iDynTree::BerdySensor, std::allocator< iDynTree::BerdySensor > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "iDynTree::BerdySensor" "," "std::allocator< iDynTree::BerdySensor >" " >";
	  }
	};
      }
    
SWIGINTERN std::vector< iDynTree::BerdySensor >::value_type std_vector_Sl_iDynTree_BerdySensor_Sg__pop(std::vector< iDynTree::BerdySensor > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< iDynTree::BerdySensor,std::allocator< iDynTree::BerdySensor > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN std::vector< iDynTree::BerdySensor >::value_type std_vector_Sl_iDynTree_BerdySensor_Sg__brace(std::vector< iDynTree::BerdySensor > *self,std::vector< iDynTree::BerdySensor >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_iDynTree_BerdySensor_Sg__setbrace(std::vector< iDynTree::BerdySensor > *self,std::vector< iDynTree::BerdySensor >::value_type x,std::vector< iDynTree::BerdySensor >::difference_type i){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN void std_vector_Sl_iDynTree_BerdySensor_Sg__append(std::vector< iDynTree::BerdySensor > *self,std::vector< iDynTree::BerdySensor >::value_type x){
      self->push_back(x);
    }
SWIGINTERN std::vector< iDynTree::BerdySensor >::iterator std_vector_Sl_iDynTree_BerdySensor_Sg__erase__SWIG_0(std::vector< iDynTree::BerdySensor > *self,std::vector< iDynTree::BerdySensor >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< iDynTree::BerdySensor >::iterator std_vector_Sl_iDynTree_BerdySensor_Sg__erase__SWIG_1(std::vector< iDynTree::BerdySensor > *self,std::vector< iDynTree::BerdySensor >::iterator first,std::vector< iDynTree::BerdySensor >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< iDynTree::BerdySensor >::iterator std_vector_Sl_iDynTree_BerdySensor_Sg__insert__SWIG_0(std::vector< iDynTree::BerdySensor > *self,std::vector< iDynTree::BerdySensor >::iterator pos,std::vector< iDynTree::BerdySensor >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_iDynTree_BerdySensor_Sg__insert__SWIG_1(std::vector< iDynTree::BerdySensor > *self,std::vector< iDynTree::BerdySensor >::iterator pos,std::vector< iDynTree::BerdySensor >::size_type n,std::vector< iDynTree::BerdySensor >::value_type const &x){ self->insert(pos, n, x); }

  namespace swig {
    template <>  struct traits< iDynTree::BerdyDynamicVariable > {
      typedef pointer_category category;
      static const char* type_name() { return"iDynTree::BerdyDynamicVariable"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< iDynTree::BerdyDynamicVariable, std::allocator< iDynTree::BerdyDynamicVariable > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "iDynTree::BerdyDynamicVariable" "," "std::allocator< iDynTree::BerdyDynamicVariable >" " >";
	  }
	};
      }
    
SWIGINTERN std::vector< iDynTree::BerdyDynamicVariable >::value_type std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__pop(std::vector< iDynTree::BerdyDynamicVariable > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< iDynTree::BerdyDynamicVariable,std::allocator< iDynTree::BerdyDynamicVariable > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN std::vector< iDynTree::BerdyDynamicVariable >::value_type std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__brace(std::vector< iDynTree::BerdyDynamicVariable > *self,std::vector< iDynTree::BerdyDynamicVariable >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__setbrace(std::vector< iDynTree::BerdyDynamicVariable > *self,std::vector< iDynTree::BerdyDynamicVariable >::value_type x,std::vector< iDynTree::BerdyDynamicVariable >::difference_type i){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN void std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__append(std::vector< iDynTree::BerdyDynamicVariable > *self,std::vector< iDynTree::BerdyDynamicVariable >::value_type x){
      self->push_back(x);
    }
SWIGINTERN std::vector< iDynTree::BerdyDynamicVariable >::iterator std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__erase__SWIG_0(std::vector< iDynTree::BerdyDynamicVariable > *self,std::vector< iDynTree::BerdyDynamicVariable >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< iDynTree::BerdyDynamicVariable >::iterator std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__erase__SWIG_1(std::vector< iDynTree::BerdyDynamicVariable > *self,std::vector< iDynTree::BerdyDynamicVariable >::iterator first,std::vector< iDynTree::BerdyDynamicVariable >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< iDynTree::BerdyDynamicVariable >::iterator std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__insert__SWIG_0(std::vector< iDynTree::BerdyDynamicVariable > *self,std::vector< iDynTree::BerdyDynamicVariable >::iterator pos,std::vector< iDynTree::BerdyDynamicVariable >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__insert__SWIG_1(std::vector< iDynTree::BerdyDynamicVariable > *self,std::vector< iDynTree::BerdyDynamicVariable >::iterator pos,std::vector< iDynTree::BerdyDynamicVariable >::size_type n,std::vector< iDynTree::BerdyDynamicVariable >::value_type const &x){ self->insert(pos, n, x); }




  SWIGINTERN int SWIG_AsVal_double (mxArray* pm, double* val)
    {
      if(!mxIsDouble(pm) || mxGetNumberOfElements(pm)!=1) return SWIG_TypeError;
      if (val) *val = mxGetScalar(pm);
      return SWIG_OK;
    }


  SWIGINTERNINLINE mxArray* SWIG_From_double    (double value)
    {    
      return mxCreateDoubleScalar(value);
    }

SWIGINTERN mxArray *iDynTree_MatrixDynSize_toMatlab(iDynTree::MatrixDynSize const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->rows(), self->cols(), mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        self->fillColMajorBuffer(d); // Column-major
        return p;
    }
SWIGINTERN void iDynTree_MatrixDynSize_fromMatlab(iDynTree::MatrixDynSize *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t rows = self->rows();
        size_t cols = self->cols();
        if (dims[0] != rows || dims[1] != cols)
        {
            self->resize(dims[0], dims[1]);
            mexWarnMsgIdAndTxt("iDynTree:Core:perfomance", "Resizing iDynTree vector to (%d,%d)", dims[0], dims[1]);
        }
        // Update rows and cols
        rows = self->rows();
        cols = self->cols();

        if (mxIsSparse(in))
        {
            /*@SWIG:/home/runner/work/idyntree/idyntree/bindings/./matlab/matlab_matvec.i,43,MATRIXSPARSECOPY@*/
    //getting pointer to sparse structure
    mwIndex* ir = mxGetIr(in);
    mwIndex* jc = mxGetJc(in);
    double *data = mxGetPr(in);

    //zero the matrix (iDynTree matrix is dense)
    self->zero();
    for (mwIndex col = 0; col < cols; col++)
    {
        /*
            jc[col] contains information about the nonzero values.
            jc[col + 1] - jc[col] = number of nonzero elements in column col
            These nonzero elements can be access with a for loop starting at
            jc[col] and ending at jc[col + 1] - 1.

        */
        mwIndex startingRowIndex = jc[col];
        mwIndex endRowIndex = jc[col + 1];
        if (startingRowIndex == endRowIndex)
        {
            //no elements in this column
            continue;
        }
        for (mwIndex currentIndex = startingRowIndex; currentIndex < endRowIndex; currentIndex++)
        {
            //access the element
            mwIndex row = ir[currentIndex];
            self->operator()(row, col) = data[currentIndex];
        }
    }
/*@SWIG@*/
        } else {
            double* d = static_cast<double*>(mxGetData(in));
            for (size_t row = 0; row < rows; row++)
            {
                for (size_t col = 0; col < cols; col++)
                {
                    self->operator()(row,col) = d[col*rows + row];
                }
            }
            return;
        }
    }

SWIGINTERN int
SWIG_AsVal_bool (mxArray* pm, bool *val)
{
   if(!mxIsLogicalScalar(pm)) return SWIG_TypeError;
   if (val) *val = mxIsLogicalScalarTrue(pm);
   return SWIG_OK;
}

SWIGINTERN mxArray *iDynTree_SparseMatrix_Sl_iDynTree_RowMajor_Sg__toMatlab(iDynTree::SparseMatrix< iDynTree::RowMajor > const *self){
        mxArray *p = mxCreateSparse(self->rows(), self->columns(),
                                    self->numberOfNonZeros(), mxREAL);
        if (!p) return 0;
        
        iDynTree::SparseMatrix<iDynTree::ColumnMajor> colMajorMatrix;
        colMajorMatrix = *self;

        mwIndex* ir = mxGetIr(p);
        mwIndex* jc = mxGetJc(p);
        double *data = mxGetPr(p);

        double const * matrixBuffer = colMajorMatrix.valuesBuffer();
        int const * tempIr = colMajorMatrix.innerIndicesBuffer();
        int const * tempJc = colMajorMatrix.outerIndicesBuffer();

        //copy back into real arrays
        for (unsigned i = 0; i < colMajorMatrix.numberOfNonZeros(); ++i) {
            ir[i] = tempIr[i];
            data[i] = matrixBuffer[i];
        }
        for (unsigned i = 0; i < colMajorMatrix.columns() + 1; ++i) {
            jc[i] = tempJc[i];
        }
        return p;
    }
SWIGINTERN mxArray *iDynTree_SparseMatrix_Sl_iDynTree_RowMajor_Sg__toMatlabDense(iDynTree::SparseMatrix< iDynTree::RowMajor > const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->rows(), self->columns(), mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        //mapping output matrix to dense 
        memset(d, 0, sizeof(double) * self->rows() * self->columns());
        //mapping output matrix to dense
        for (typename iDynTree::SparseMatrix<iDynTree::RowMajor>::const_iterator it(self->begin());
             it != self->end(); ++it) {
            d[self->rows() * it->column + it->row] = it->value;

        }
        return p;
    }
SWIGINTERN void iDynTree_SparseMatrix_Sl_iDynTree_RowMajor_Sg__fromMatlab(iDynTree::SparseMatrix< iDynTree::RowMajor > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t rows = dims[0];
        size_t cols = dims[1];
        if (self->rows() != rows || self->columns() != cols)
        {
            self->resize(rows, cols);
            mexWarnMsgIdAndTxt("iDynTree:Core:perfomance", "Resizing iDynTree vector to (%d,%d)", rows, cols);
        }

        if (mxIsSparse(in))
        {
            mwIndex* ir = mxGetIr(in);
            mwIndex* jc = mxGetJc(in);
            double *data = mxGetPr(in);
            const mwSize * dims = mxGetDimensions(in);
            mwIndex nnz = jc[dims[1]];
            
            iDynTree::Triplets triplets;
            triplets.reserve(nnz);

            //fill triplets
            for (size_t col = 0; col < cols; ++col) {
                //iterate over the rows nz
                for (int innerIndex = jc[col]; innerIndex < jc[col + 1]; ++innerIndex) {
                    triplets.pushTriplet(iDynTree::Triplet(ir[innerIndex], col, data[innerIndex]));
                }
            }

            self->setFromTriplets(triplets);

        } else {
            double* d = static_cast<double*>(mxGetData(in));

            iDynTree::Triplets triplets;
            triplets.reserve(rows * cols);

            for (size_t row = 0; row < rows; row++)
            {
                for (size_t col = 0; col < cols; col++)
                {
                    // probably this should be substituted with a check to eps
                    if (d[col * rows + row] == 0) continue;
                    triplets.pushTriplet(iDynTree::Triplet(row, col, d[col * rows + row]));
                }
            }
            self->setFromTriplets(triplets);
            
            return;
        }
    }
SWIGINTERN mxArray *iDynTree_SparseMatrix_Sl_iDynTree_ColumnMajor_Sg__toMatlab(iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *self){
        mxArray *p = mxCreateSparse(self->rows(), self->columns(),
                                    self->numberOfNonZeros(), mxREAL);
        if (!p) return 0;

        mwIndex* ir = mxGetIr(p);
        mwIndex* jc = mxGetJc(p);
        double *data = mxGetPr(p);

        double const * matrixBuffer = self->valuesBuffer();
        int const * tempIr = self->innerIndicesBuffer();
        int const * tempJc = self->outerIndicesBuffer();

        //copy back into real arrays
        for (unsigned i = 0; i < self->numberOfNonZeros(); ++i) {
            ir[i] = tempIr[i];
            data[i] = matrixBuffer[i];
        }
        for (unsigned i = 0; i < self->columns() + 1; ++i) {
            jc[i] = tempJc[i];
        }
        return p;
    }
SWIGINTERN mxArray *iDynTree_SparseMatrix_Sl_iDynTree_ColumnMajor_Sg__toMatlabDense(iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->rows(), self->columns(), mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        //mapping output matrix to dense 
        memset(d, 0, sizeof(double) * self->rows() * self->columns());
        //mapping output matrix to dense
        for (typename iDynTree::SparseMatrix<iDynTree::ColumnMajor>::const_iterator it(self->begin());
             it != self->end(); ++it) {
            d[self->rows() * it->column + it->row] = it->value;

        }
        return p;
    }
SWIGINTERN void iDynTree_SparseMatrix_Sl_iDynTree_ColumnMajor_Sg__fromMatlab(iDynTree::SparseMatrix< iDynTree::ColumnMajor > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t rows = dims[0];
        size_t cols = dims[1];
        if (self->rows() != rows || self->columns() != cols)
        {
            self->resize(rows, cols);
            mexWarnMsgIdAndTxt("iDynTree:Core:perfomance", "Resizing iDynTree vector to (%d,%d)", rows, cols);
        }

        if (mxIsSparse(in))
        {
            mwIndex* ir = mxGetIr(in);
            mwIndex* jc = mxGetJc(in);
            double *data = mxGetPr(in);
            const mwSize * dims = mxGetDimensions(in);
            mwIndex nnz = jc[dims[1]];
            
            iDynTree::Triplets triplets;
            triplets.reserve(nnz);

            //fill triplets
            for (size_t col = 0; col < cols; ++col) {
                //iterate over the rows nz
                for (int innerIndex = jc[col]; innerIndex < jc[col + 1]; ++innerIndex) {
                    triplets.pushTriplet(iDynTree::Triplet(ir[innerIndex], col, data[innerIndex]));
                }
            }

            self->setFromTriplets(triplets);

        } else {
            double* d = static_cast<double*>(mxGetData(in));

            iDynTree::Triplets triplets;
            triplets.reserve(rows * cols);

            for (size_t row = 0; row < rows; row++)
            {
                for (size_t col = 0; col < cols; col++)
                {
                    // probably this should be substituted with a check to eps
                    if (d[col * rows + row] == 0) continue;
                    triplets.pushTriplet(iDynTree::Triplet(row, col, d[col * rows + row]));
                }
            }
            self->setFromTriplets(triplets);
            
            return;
        }
    }
SWIGINTERN mxArray *iDynTree_VectorDynSize_toMatlab(iDynTree::VectorDynSize const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->size(), 1, mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        self->fillBuffer(d); // Column-major
        return p;
    }
SWIGINTERN void iDynTree_VectorDynSize_fromMatlab(iDynTree::VectorDynSize *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        self->size();
        if (( dims[0] == 1 || dims[1] == 1))
        {
            // Get the size of the input vector
            size_t inSize;
            if( dims[0] == 1 )
            {
                inSize = dims[1];
            }
            else
            {
                inSize = dims[0];
            }

            // If the input vector has a size different
            // from the one of the iDynTree::VectorDynSize,
            // we resize iDynTree::VectorDynSize
            if( self->size() != inSize )
            {
                self->resize(inSize);
                mexWarnMsgIdAndTxt("iDynTree:Core:perfomance", "Resizing iDynTree vector to %d", inSize);
            }

            if (mxIsSparse(in))
            {
                /*@SWIG:/home/runner/work/idyntree/idyntree/bindings/./matlab/matlab_matvec.i,6,VECTORSPARSECOPY@*/
    //getting pointer to sparse structure
    mwIndex* ir = mxGetIr(in);
    mwIndex* jc = mxGetJc(in);
    double *data = mxGetPr(in);

    //If dims[1] == 1 assume it is a column vector (or a 1 element vector)
    bool isColumnVector = (dims[1] == 1);

    //zero the matrix (iDynTree vector is dense)
    self->zero();
    for (mwIndex col = 0; col < dims[1]; col++)
    {
        /*
            jc[col] contains information about the nonzero values.
            jc[col + 1] - jc[col] = number of nonzero elements in column col
            These nonzero elements can be access with a for loop starting at
            jc[col] and ending at jc[col + 1] - 1.

        */
        mwIndex startingRowIndex = jc[col];
        mwIndex endRowIndex = jc[col + 1];
        if (startingRowIndex == endRowIndex)
        {
            //no elements in this column
            continue;
        }
        for (mwIndex currentIndex = startingRowIndex; currentIndex < endRowIndex; currentIndex++)
        {
            //access the element
            mwIndex row = ir[currentIndex];
            //iDynTree has only one size.
            self->operator()(isColumnVector ? row : col) = data[currentIndex];
        }
    }
/*@SWIG@*/
            } else {
                double* d = static_cast<double*>(mxGetData(in));
                double* selfData = self->data();
                for(size_t i=0; i < inSize; i++ )
                {
                    selfData[i] = d[i];
                }
            }
            return;
        }
    }
SWIGINTERN mxArray *iDynTree_MatrixFixSize_Sl_1_Sc_6_Sg__toMatlab(iDynTree::MatrixFixSize< 1,6 > const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->rows(), self->cols(), mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        self->fillColMajorBuffer(d); // Column-major
        return p;
    }
SWIGINTERN void iDynTree_MatrixFixSize_Sl_1_Sc_6_Sg__fromMatlab(iDynTree::MatrixFixSize< 1,6 > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t fixValRows = self->rows();
        size_t fixValCols = self->cols();
        if (dims[0] == fixValRows && dims[1] == fixValCols)
        {
            if (mxIsSparse(in))
            {
                /*@SWIG:/home/runner/work/idyntree/idyntree/bindings/./matlab/matlab_matvec.i,43,MATRIXSPARSECOPY@*/
    //getting pointer to sparse structure
    mwIndex* ir = mxGetIr(in);
    mwIndex* jc = mxGetJc(in);
    double *data = mxGetPr(in);

    //zero the matrix (iDynTree matrix is dense)
    self->zero();
    for (mwIndex col = 0; col < fixValCols; col++)
    {
        /*
            jc[col] contains information about the nonzero values.
            jc[col + 1] - jc[col] = number of nonzero elements in column col
            These nonzero elements can be access with a for loop starting at
            jc[col] and ending at jc[col + 1] - 1.

        */
        mwIndex startingRowIndex = jc[col];
        mwIndex endRowIndex = jc[col + 1];
        if (startingRowIndex == endRowIndex)
        {
            //no elements in this column
            continue;
        }
        for (mwIndex currentIndex = startingRowIndex; currentIndex < endRowIndex; currentIndex++)
        {
            //access the element
            mwIndex row = ir[currentIndex];
            self->operator()(row, col) = data[currentIndex];
        }
    }
/*@SWIG@*/
            } else {
                double* d = static_cast<double*>(mxGetData(in));
                for (size_t row = 0; row < fixValRows; row++)
                {
                    for (size_t col = 0; col < fixValCols; col++)
                    {
                        self->operator()(row,col) = d[col*fixValRows + row];
                    }
                }
                return;
            }
         } else {
            mexErrMsgIdAndTxt("iDynTree:Core:wrongDimension",
              "Wrong matrix size. Matlab size: (%d,%d). iDynTree size: (%d,%d)", dims[0], dims[1], fixValRows, fixValCols);
        }
    }
SWIGINTERN mxArray *iDynTree_MatrixFixSize_Sl_2_Sc_3_Sg__toMatlab(iDynTree::MatrixFixSize< 2,3 > const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->rows(), self->cols(), mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        self->fillColMajorBuffer(d); // Column-major
        return p;
    }
SWIGINTERN void iDynTree_MatrixFixSize_Sl_2_Sc_3_Sg__fromMatlab(iDynTree::MatrixFixSize< 2,3 > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t fixValRows = self->rows();
        size_t fixValCols = self->cols();
        if (dims[0] == fixValRows && dims[1] == fixValCols)
        {
            if (mxIsSparse(in))
            {
                /*@SWIG:/home/runner/work/idyntree/idyntree/bindings/./matlab/matlab_matvec.i,43,MATRIXSPARSECOPY@*/
    //getting pointer to sparse structure
    mwIndex* ir = mxGetIr(in);
    mwIndex* jc = mxGetJc(in);
    double *data = mxGetPr(in);

    //zero the matrix (iDynTree matrix is dense)
    self->zero();
    for (mwIndex col = 0; col < fixValCols; col++)
    {
        /*
            jc[col] contains information about the nonzero values.
            jc[col + 1] - jc[col] = number of nonzero elements in column col
            These nonzero elements can be access with a for loop starting at
            jc[col] and ending at jc[col + 1] - 1.

        */
        mwIndex startingRowIndex = jc[col];
        mwIndex endRowIndex = jc[col + 1];
        if (startingRowIndex == endRowIndex)
        {
            //no elements in this column
            continue;
        }
        for (mwIndex currentIndex = startingRowIndex; currentIndex < endRowIndex; currentIndex++)
        {
            //access the element
            mwIndex row = ir[currentIndex];
            self->operator()(row, col) = data[currentIndex];
        }
    }
/*@SWIG@*/
            } else {
                double* d = static_cast<double*>(mxGetData(in));
                for (size_t row = 0; row < fixValRows; row++)
                {
                    for (size_t col = 0; col < fixValCols; col++)
                    {
                        self->operator()(row,col) = d[col*fixValRows + row];
                    }
                }
                return;
            }
         } else {
            mexErrMsgIdAndTxt("iDynTree:Core:wrongDimension",
              "Wrong matrix size. Matlab size: (%d,%d). iDynTree size: (%d,%d)", dims[0], dims[1], fixValRows, fixValCols);
        }
    }
SWIGINTERN mxArray *iDynTree_MatrixFixSize_Sl_3_Sc_3_Sg__toMatlab(iDynTree::MatrixFixSize< 3,3 > const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->rows(), self->cols(), mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        self->fillColMajorBuffer(d); // Column-major
        return p;
    }
SWIGINTERN void iDynTree_MatrixFixSize_Sl_3_Sc_3_Sg__fromMatlab(iDynTree::MatrixFixSize< 3,3 > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t fixValRows = self->rows();
        size_t fixValCols = self->cols();
        if (dims[0] == fixValRows && dims[1] == fixValCols)
        {
            if (mxIsSparse(in))
            {
                /*@SWIG:/home/runner/work/idyntree/idyntree/bindings/./matlab/matlab_matvec.i,43,MATRIXSPARSECOPY@*/
    //getting pointer to sparse structure
    mwIndex* ir = mxGetIr(in);
    mwIndex* jc = mxGetJc(in);
    double *data = mxGetPr(in);

    //zero the matrix (iDynTree matrix is dense)
    self->zero();
    for (mwIndex col = 0; col < fixValCols; col++)
    {
        /*
            jc[col] contains information about the nonzero values.
            jc[col + 1] - jc[col] = number of nonzero elements in column col
            These nonzero elements can be access with a for loop starting at
            jc[col] and ending at jc[col + 1] - 1.

        */
        mwIndex startingRowIndex = jc[col];
        mwIndex endRowIndex = jc[col + 1];
        if (startingRowIndex == endRowIndex)
        {
            //no elements in this column
            continue;
        }
        for (mwIndex currentIndex = startingRowIndex; currentIndex < endRowIndex; currentIndex++)
        {
            //access the element
            mwIndex row = ir[currentIndex];
            self->operator()(row, col) = data[currentIndex];
        }
    }
/*@SWIG@*/
            } else {
                double* d = static_cast<double*>(mxGetData(in));
                for (size_t row = 0; row < fixValRows; row++)
                {
                    for (size_t col = 0; col < fixValCols; col++)
                    {
                        self->operator()(row,col) = d[col*fixValRows + row];
                    }
                }
                return;
            }
         } else {
            mexErrMsgIdAndTxt("iDynTree:Core:wrongDimension",
              "Wrong matrix size. Matlab size: (%d,%d). iDynTree size: (%d,%d)", dims[0], dims[1], fixValRows, fixValCols);
        }
    }
SWIGINTERN mxArray *iDynTree_MatrixFixSize_Sl_4_Sc_4_Sg__toMatlab(iDynTree::MatrixFixSize< 4,4 > const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->rows(), self->cols(), mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        self->fillColMajorBuffer(d); // Column-major
        return p;
    }
SWIGINTERN void iDynTree_MatrixFixSize_Sl_4_Sc_4_Sg__fromMatlab(iDynTree::MatrixFixSize< 4,4 > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t fixValRows = self->rows();
        size_t fixValCols = self->cols();
        if (dims[0] == fixValRows && dims[1] == fixValCols)
        {
            if (mxIsSparse(in))
            {
                /*@SWIG:/home/runner/work/idyntree/idyntree/bindings/./matlab/matlab_matvec.i,43,MATRIXSPARSECOPY@*/
    //getting pointer to sparse structure
    mwIndex* ir = mxGetIr(in);
    mwIndex* jc = mxGetJc(in);
    double *data = mxGetPr(in);

    //zero the matrix (iDynTree matrix is dense)
    self->zero();
    for (mwIndex col = 0; col < fixValCols; col++)
    {
        /*
            jc[col] contains information about the nonzero values.
            jc[col + 1] - jc[col] = number of nonzero elements in column col
            These nonzero elements can be access with a for loop starting at
            jc[col] and ending at jc[col + 1] - 1.

        */
        mwIndex startingRowIndex = jc[col];
        mwIndex endRowIndex = jc[col + 1];
        if (startingRowIndex == endRowIndex)
        {
            //no elements in this column
            continue;
        }
        for (mwIndex currentIndex = startingRowIndex; currentIndex < endRowIndex; currentIndex++)
        {
            //access the element
            mwIndex row = ir[currentIndex];
            self->operator()(row, col) = data[currentIndex];
        }
    }
/*@SWIG@*/
            } else {
                double* d = static_cast<double*>(mxGetData(in));
                for (size_t row = 0; row < fixValRows; row++)
                {
                    for (size_t col = 0; col < fixValCols; col++)
                    {
                        self->operator()(row,col) = d[col*fixValRows + row];
                    }
                }
                return;
            }
         } else {
            mexErrMsgIdAndTxt("iDynTree:Core:wrongDimension",
              "Wrong matrix size. Matlab size: (%d,%d). iDynTree size: (%d,%d)", dims[0], dims[1], fixValRows, fixValCols);
        }
    }
SWIGINTERN mxArray *iDynTree_MatrixFixSize_Sl_6_Sc_6_Sg__toMatlab(iDynTree::MatrixFixSize< 6,6 > const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->rows(), self->cols(), mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        self->fillColMajorBuffer(d); // Column-major
        return p;
    }
SWIGINTERN void iDynTree_MatrixFixSize_Sl_6_Sc_6_Sg__fromMatlab(iDynTree::MatrixFixSize< 6,6 > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t fixValRows = self->rows();
        size_t fixValCols = self->cols();
        if (dims[0] == fixValRows && dims[1] == fixValCols)
        {
            if (mxIsSparse(in))
            {
                /*@SWIG:/home/runner/work/idyntree/idyntree/bindings/./matlab/matlab_matvec.i,43,MATRIXSPARSECOPY@*/
    //getting pointer to sparse structure
    mwIndex* ir = mxGetIr(in);
    mwIndex* jc = mxGetJc(in);
    double *data = mxGetPr(in);

    //zero the matrix (iDynTree matrix is dense)
    self->zero();
    for (mwIndex col = 0; col < fixValCols; col++)
    {
        /*
            jc[col] contains information about the nonzero values.
            jc[col + 1] - jc[col] = number of nonzero elements in column col
            These nonzero elements can be access with a for loop starting at
            jc[col] and ending at jc[col + 1] - 1.

        */
        mwIndex startingRowIndex = jc[col];
        mwIndex endRowIndex = jc[col + 1];
        if (startingRowIndex == endRowIndex)
        {
            //no elements in this column
            continue;
        }
        for (mwIndex currentIndex = startingRowIndex; currentIndex < endRowIndex; currentIndex++)
        {
            //access the element
            mwIndex row = ir[currentIndex];
            self->operator()(row, col) = data[currentIndex];
        }
    }
/*@SWIG@*/
            } else {
                double* d = static_cast<double*>(mxGetData(in));
                for (size_t row = 0; row < fixValRows; row++)
                {
                    for (size_t col = 0; col < fixValCols; col++)
                    {
                        self->operator()(row,col) = d[col*fixValRows + row];
                    }
                }
                return;
            }
         } else {
            mexErrMsgIdAndTxt("iDynTree:Core:wrongDimension",
              "Wrong matrix size. Matlab size: (%d,%d). iDynTree size: (%d,%d)", dims[0], dims[1], fixValRows, fixValCols);
        }
    }
SWIGINTERN mxArray *iDynTree_MatrixFixSize_Sl_6_Sc_10_Sg__toMatlab(iDynTree::MatrixFixSize< 6,10 > const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->rows(), self->cols(), mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        self->fillColMajorBuffer(d); // Column-major
        return p;
    }
SWIGINTERN void iDynTree_MatrixFixSize_Sl_6_Sc_10_Sg__fromMatlab(iDynTree::MatrixFixSize< 6,10 > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t fixValRows = self->rows();
        size_t fixValCols = self->cols();
        if (dims[0] == fixValRows && dims[1] == fixValCols)
        {
            if (mxIsSparse(in))
            {
                /*@SWIG:/home/runner/work/idyntree/idyntree/bindings/./matlab/matlab_matvec.i,43,MATRIXSPARSECOPY@*/
    //getting pointer to sparse structure
    mwIndex* ir = mxGetIr(in);
    mwIndex* jc = mxGetJc(in);
    double *data = mxGetPr(in);

    //zero the matrix (iDynTree matrix is dense)
    self->zero();
    for (mwIndex col = 0; col < fixValCols; col++)
    {
        /*
            jc[col] contains information about the nonzero values.
            jc[col + 1] - jc[col] = number of nonzero elements in column col
            These nonzero elements can be access with a for loop starting at
            jc[col] and ending at jc[col + 1] - 1.

        */
        mwIndex startingRowIndex = jc[col];
        mwIndex endRowIndex = jc[col + 1];
        if (startingRowIndex == endRowIndex)
        {
            //no elements in this column
            continue;
        }
        for (mwIndex currentIndex = startingRowIndex; currentIndex < endRowIndex; currentIndex++)
        {
            //access the element
            mwIndex row = ir[currentIndex];
            self->operator()(row, col) = data[currentIndex];
        }
    }
/*@SWIG@*/
            } else {
                double* d = static_cast<double*>(mxGetData(in));
                for (size_t row = 0; row < fixValRows; row++)
                {
                    for (size_t col = 0; col < fixValCols; col++)
                    {
                        self->operator()(row,col) = d[col*fixValRows + row];
                    }
                }
                return;
            }
         } else {
            mexErrMsgIdAndTxt("iDynTree:Core:wrongDimension",
              "Wrong matrix size. Matlab size: (%d,%d). iDynTree size: (%d,%d)", dims[0], dims[1], fixValRows, fixValCols);
        }
    }
SWIGINTERN mxArray *iDynTree_MatrixFixSize_Sl_10_Sc_16_Sg__toMatlab(iDynTree::MatrixFixSize< 10,16 > const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->rows(), self->cols(), mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        self->fillColMajorBuffer(d); // Column-major
        return p;
    }
SWIGINTERN void iDynTree_MatrixFixSize_Sl_10_Sc_16_Sg__fromMatlab(iDynTree::MatrixFixSize< 10,16 > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t fixValRows = self->rows();
        size_t fixValCols = self->cols();
        if (dims[0] == fixValRows && dims[1] == fixValCols)
        {
            if (mxIsSparse(in))
            {
                /*@SWIG:/home/runner/work/idyntree/idyntree/bindings/./matlab/matlab_matvec.i,43,MATRIXSPARSECOPY@*/
    //getting pointer to sparse structure
    mwIndex* ir = mxGetIr(in);
    mwIndex* jc = mxGetJc(in);
    double *data = mxGetPr(in);

    //zero the matrix (iDynTree matrix is dense)
    self->zero();
    for (mwIndex col = 0; col < fixValCols; col++)
    {
        /*
            jc[col] contains information about the nonzero values.
            jc[col + 1] - jc[col] = number of nonzero elements in column col
            These nonzero elements can be access with a for loop starting at
            jc[col] and ending at jc[col + 1] - 1.

        */
        mwIndex startingRowIndex = jc[col];
        mwIndex endRowIndex = jc[col + 1];
        if (startingRowIndex == endRowIndex)
        {
            //no elements in this column
            continue;
        }
        for (mwIndex currentIndex = startingRowIndex; currentIndex < endRowIndex; currentIndex++)
        {
            //access the element
            mwIndex row = ir[currentIndex];
            self->operator()(row, col) = data[currentIndex];
        }
    }
/*@SWIG@*/
            } else {
                double* d = static_cast<double*>(mxGetData(in));
                for (size_t row = 0; row < fixValRows; row++)
                {
                    for (size_t col = 0; col < fixValCols; col++)
                    {
                        self->operator()(row,col) = d[col*fixValRows + row];
                    }
                }
                return;
            }
         } else {
            mexErrMsgIdAndTxt("iDynTree:Core:wrongDimension",
              "Wrong matrix size. Matlab size: (%d,%d). iDynTree size: (%d,%d)", dims[0], dims[1], fixValRows, fixValCols);
        }
    }
SWIGINTERN mxArray *iDynTree_VectorFixSize_Sl_3_Sg__toMatlab(iDynTree::VectorFixSize< 3 > const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->size(), 1, mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        self->fillBuffer(d); // Column-major
        return p;
    }
SWIGINTERN void iDynTree_VectorFixSize_Sl_3_Sg__fromMatlab(iDynTree::VectorFixSize< 3 > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t fixValSize = self->size();
        size_t nonSingletonDimension = (dims[0] == 1 ? dims[1] : dims[0]);

        if (nonSingletonDimension == fixValSize)
        {
            if (mxIsSparse(in))
            {
                /*@SWIG:/home/runner/work/idyntree/idyntree/bindings/./matlab/matlab_matvec.i,6,VECTORSPARSECOPY@*/
    //getting pointer to sparse structure
    mwIndex* ir = mxGetIr(in);
    mwIndex* jc = mxGetJc(in);
    double *data = mxGetPr(in);

    //If dims[1] == 1 assume it is a column vector (or a 1 element vector)
    bool isColumnVector = (dims[1] == 1);

    //zero the matrix (iDynTree vector is dense)
    self->zero();
    for (mwIndex col = 0; col < dims[1]; col++)
    {
        /*
            jc[col] contains information about the nonzero values.
            jc[col + 1] - jc[col] = number of nonzero elements in column col
            These nonzero elements can be access with a for loop starting at
            jc[col] and ending at jc[col + 1] - 1.

        */
        mwIndex startingRowIndex = jc[col];
        mwIndex endRowIndex = jc[col + 1];
        if (startingRowIndex == endRowIndex)
        {
            //no elements in this column
            continue;
        }
        for (mwIndex currentIndex = startingRowIndex; currentIndex < endRowIndex; currentIndex++)
        {
            //access the element
            mwIndex row = ir[currentIndex];
            //iDynTree has only one size.
            self->operator()(isColumnVector ? row : col) = data[currentIndex];
        }
    }
/*@SWIG@*/
            } else {
                double* d = static_cast<double*>(mxGetData(in));
                double* selfData = self->data();
                for(size_t i=0; i < fixValSize; i++ )
                {
                    selfData[i] = d[i];
                }
            }
            return;
        } else {
            mexErrMsgIdAndTxt("iDynTree:Core:wrongDimension",
              "Wrong vector size. Matlab size: %d. iDynTree size: %d", nonSingletonDimension, fixValSize);
        }
    }
SWIGINTERN mxArray *iDynTree_VectorFixSize_Sl_4_Sg__toMatlab(iDynTree::VectorFixSize< 4 > const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->size(), 1, mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        self->fillBuffer(d); // Column-major
        return p;
    }
SWIGINTERN void iDynTree_VectorFixSize_Sl_4_Sg__fromMatlab(iDynTree::VectorFixSize< 4 > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t fixValSize = self->size();
        size_t nonSingletonDimension = (dims[0] == 1 ? dims[1] : dims[0]);

        if (nonSingletonDimension == fixValSize)
        {
            if (mxIsSparse(in))
            {
                /*@SWIG:/home/runner/work/idyntree/idyntree/bindings/./matlab/matlab_matvec.i,6,VECTORSPARSECOPY@*/
    //getting pointer to sparse structure
    mwIndex* ir = mxGetIr(in);
    mwIndex* jc = mxGetJc(in);
    double *data = mxGetPr(in);

    //If dims[1] == 1 assume it is a column vector (or a 1 element vector)
    bool isColumnVector = (dims[1] == 1);

    //zero the matrix (iDynTree vector is dense)
    self->zero();
    for (mwIndex col = 0; col < dims[1]; col++)
    {
        /*
            jc[col] contains information about the nonzero values.
            jc[col + 1] - jc[col] = number of nonzero elements in column col
            These nonzero elements can be access with a for loop starting at
            jc[col] and ending at jc[col + 1] - 1.

        */
        mwIndex startingRowIndex = jc[col];
        mwIndex endRowIndex = jc[col + 1];
        if (startingRowIndex == endRowIndex)
        {
            //no elements in this column
            continue;
        }
        for (mwIndex currentIndex = startingRowIndex; currentIndex < endRowIndex; currentIndex++)
        {
            //access the element
            mwIndex row = ir[currentIndex];
            //iDynTree has only one size.
            self->operator()(isColumnVector ? row : col) = data[currentIndex];
        }
    }
/*@SWIG@*/
            } else {
                double* d = static_cast<double*>(mxGetData(in));
                double* selfData = self->data();
                for(size_t i=0; i < fixValSize; i++ )
                {
                    selfData[i] = d[i];
                }
            }
            return;
        } else {
            mexErrMsgIdAndTxt("iDynTree:Core:wrongDimension",
              "Wrong vector size. Matlab size: %d. iDynTree size: %d", nonSingletonDimension, fixValSize);
        }
    }
SWIGINTERN mxArray *iDynTree_VectorFixSize_Sl_6_Sg__toMatlab(iDynTree::VectorFixSize< 6 > const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->size(), 1, mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        self->fillBuffer(d); // Column-major
        return p;
    }
SWIGINTERN void iDynTree_VectorFixSize_Sl_6_Sg__fromMatlab(iDynTree::VectorFixSize< 6 > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t fixValSize = self->size();
        size_t nonSingletonDimension = (dims[0] == 1 ? dims[1] : dims[0]);

        if (nonSingletonDimension == fixValSize)
        {
            if (mxIsSparse(in))
            {
                /*@SWIG:/home/runner/work/idyntree/idyntree/bindings/./matlab/matlab_matvec.i,6,VECTORSPARSECOPY@*/
    //getting pointer to sparse structure
    mwIndex* ir = mxGetIr(in);
    mwIndex* jc = mxGetJc(in);
    double *data = mxGetPr(in);

    //If dims[1] == 1 assume it is a column vector (or a 1 element vector)
    bool isColumnVector = (dims[1] == 1);

    //zero the matrix (iDynTree vector is dense)
    self->zero();
    for (mwIndex col = 0; col < dims[1]; col++)
    {
        /*
            jc[col] contains information about the nonzero values.
            jc[col + 1] - jc[col] = number of nonzero elements in column col
            These nonzero elements can be access with a for loop starting at
            jc[col] and ending at jc[col + 1] - 1.

        */
        mwIndex startingRowIndex = jc[col];
        mwIndex endRowIndex = jc[col + 1];
        if (startingRowIndex == endRowIndex)
        {
            //no elements in this column
            continue;
        }
        for (mwIndex currentIndex = startingRowIndex; currentIndex < endRowIndex; currentIndex++)
        {
            //access the element
            mwIndex row = ir[currentIndex];
            //iDynTree has only one size.
            self->operator()(isColumnVector ? row : col) = data[currentIndex];
        }
    }
/*@SWIG@*/
            } else {
                double* d = static_cast<double*>(mxGetData(in));
                double* selfData = self->data();
                for(size_t i=0; i < fixValSize; i++ )
                {
                    selfData[i] = d[i];
                }
            }
            return;
        } else {
            mexErrMsgIdAndTxt("iDynTree:Core:wrongDimension",
              "Wrong vector size. Matlab size: %d. iDynTree size: %d", nonSingletonDimension, fixValSize);
        }
    }
SWIGINTERN mxArray *iDynTree_VectorFixSize_Sl_10_Sg__toMatlab(iDynTree::VectorFixSize< 10 > const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->size(), 1, mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        self->fillBuffer(d); // Column-major
        return p;
    }
SWIGINTERN void iDynTree_VectorFixSize_Sl_10_Sg__fromMatlab(iDynTree::VectorFixSize< 10 > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t fixValSize = self->size();
        size_t nonSingletonDimension = (dims[0] == 1 ? dims[1] : dims[0]);

        if (nonSingletonDimension == fixValSize)
        {
            if (mxIsSparse(in))
            {
                /*@SWIG:/home/runner/work/idyntree/idyntree/bindings/./matlab/matlab_matvec.i,6,VECTORSPARSECOPY@*/
    //getting pointer to sparse structure
    mwIndex* ir = mxGetIr(in);
    mwIndex* jc = mxGetJc(in);
    double *data = mxGetPr(in);

    //If dims[1] == 1 assume it is a column vector (or a 1 element vector)
    bool isColumnVector = (dims[1] == 1);

    //zero the matrix (iDynTree vector is dense)
    self->zero();
    for (mwIndex col = 0; col < dims[1]; col++)
    {
        /*
            jc[col] contains information about the nonzero values.
            jc[col + 1] - jc[col] = number of nonzero elements in column col
            These nonzero elements can be access with a for loop starting at
            jc[col] and ending at jc[col + 1] - 1.

        */
        mwIndex startingRowIndex = jc[col];
        mwIndex endRowIndex = jc[col + 1];
        if (startingRowIndex == endRowIndex)
        {
            //no elements in this column
            continue;
        }
        for (mwIndex currentIndex = startingRowIndex; currentIndex < endRowIndex; currentIndex++)
        {
            //access the element
            mwIndex row = ir[currentIndex];
            //iDynTree has only one size.
            self->operator()(isColumnVector ? row : col) = data[currentIndex];
        }
    }
/*@SWIG@*/
            } else {
                double* d = static_cast<double*>(mxGetData(in));
                double* selfData = self->data();
                for(size_t i=0; i < fixValSize; i++ )
                {
                    selfData[i] = d[i];
                }
            }
            return;
        } else {
            mexErrMsgIdAndTxt("iDynTree:Core:wrongDimension",
              "Wrong vector size. Matlab size: %d. iDynTree size: %d", nonSingletonDimension, fixValSize);
        }
    }
SWIGINTERN mxArray *iDynTree_VectorFixSize_Sl_16_Sg__toMatlab(iDynTree::VectorFixSize< 16 > const *self){
        mxArray *p  = mxCreateDoubleMatrix(self->size(), 1, mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        self->fillBuffer(d); // Column-major
        return p;
    }
SWIGINTERN void iDynTree_VectorFixSize_Sl_16_Sg__fromMatlab(iDynTree::VectorFixSize< 16 > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t fixValSize = self->size();
        size_t nonSingletonDimension = (dims[0] == 1 ? dims[1] : dims[0]);

        if (nonSingletonDimension == fixValSize)
        {
            if (mxIsSparse(in))
            {
                /*@SWIG:/home/runner/work/idyntree/idyntree/bindings/./matlab/matlab_matvec.i,6,VECTORSPARSECOPY@*/
    //getting pointer to sparse structure
    mwIndex* ir = mxGetIr(in);
    mwIndex* jc = mxGetJc(in);
    double *data = mxGetPr(in);

    //If dims[1] == 1 assume it is a column vector (or a 1 element vector)
    bool isColumnVector = (dims[1] == 1);

    //zero the matrix (iDynTree vector is dense)
    self->zero();
    for (mwIndex col = 0; col < dims[1]; col++)
    {
        /*
            jc[col] contains information about the nonzero values.
            jc[col + 1] - jc[col] = number of nonzero elements in column col
            These nonzero elements can be access with a for loop starting at
            jc[col] and ending at jc[col + 1] - 1.

        */
        mwIndex startingRowIndex = jc[col];
        mwIndex endRowIndex = jc[col + 1];
        if (startingRowIndex == endRowIndex)
        {
            //no elements in this column
            continue;
        }
        for (mwIndex currentIndex = startingRowIndex; currentIndex < endRowIndex; currentIndex++)
        {
            //access the element
            mwIndex row = ir[currentIndex];
            //iDynTree has only one size.
            self->operator()(isColumnVector ? row : col) = data[currentIndex];
        }
    }
/*@SWIG@*/
            } else {
                double* d = static_cast<double*>(mxGetData(in));
                double* selfData = self->data();
                for(size_t i=0; i < fixValSize; i++ )
                {
                    selfData[i] = d[i];
                }
            }
            return;
        } else {
            mexErrMsgIdAndTxt("iDynTree:Core:wrongDimension",
              "Wrong vector size. Matlab size: %d. iDynTree size: %d", nonSingletonDimension, fixValSize);
        }
    }

SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (mxArray* obj, unsigned int *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UINT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned int >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE mxArray*
SWIG_From_unsigned_SS_int  (unsigned int value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}

SWIGINTERN mxArray *iDynTree_SpatialVector_Sl_iDynTree_SpatialMotionVector_Sg__toMatlab(iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *self){
        mxArray *p  = mxCreateDoubleMatrix(6, 1, mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        for(unsigned int i=0; i < 6; i++ )
        {
            d[i] = self->operator()(i);
        }

        return p;
    }
SWIGINTERN void iDynTree_SpatialVector_Sl_iDynTree_SpatialMotionVector_Sg__fromMatlab(iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t fixValSize = self->size();
        if( ( dims[0] == fixValSize && dims[1] == 1) ||
            ( dims[0] == 1 && dims[1] == fixValSize ) )
        {
            double* d = static_cast<double*>(mxGetData(in));
            for(size_t i=0; i < fixValSize; i++ )
            {
                self->operator()(i) = d[i];
            }
            return;
        }
    }
SWIGINTERN mxArray *iDynTree_SpatialVector_Sl_iDynTree_SpatialForceVector_Sg__toMatlab(iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *self){
        mxArray *p  = mxCreateDoubleMatrix(6, 1, mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        for(unsigned int i=0; i < 6; i++ )
        {
            d[i] = self->operator()(i);
        }

        return p;
    }
SWIGINTERN void iDynTree_SpatialVector_Sl_iDynTree_SpatialForceVector_Sg__fromMatlab(iDynTree::SpatialVector< iDynTree::SpatialForceVector > *self,mxArray *in){
        // check size
        const mwSize * dims = mxGetDimensions(in);
        size_t fixValSize = self->size();
        if( ( dims[0] == fixValSize && dims[1] == 1) ||
            ( dims[0] == 1 && dims[1] == fixValSize ) )
        {
            double* d = static_cast<double*>(mxGetData(in));
            for(size_t i=0; i < fixValSize; i++ )
            {
                self->operator()(i) = d[i];
            }
            return;
        }
    }
SWIGINTERN bool iDynTree_IJoint_isRevoluteJoint(iDynTree::IJoint const *self){
        const iDynTree::RevoluteJoint * p =
            dynamic_cast<const iDynTree::RevoluteJoint*>(self);
        return (p != 0);
    }
SWIGINTERN bool iDynTree_IJoint_isFixedJoint(iDynTree::IJoint const *self){
        const iDynTree::FixedJoint * p =
            dynamic_cast<const iDynTree::FixedJoint*>(self);
        return (p != 0);
    }
SWIGINTERN iDynTree::RevoluteJoint *iDynTree_IJoint_asRevoluteJoint(iDynTree::IJoint *self){
        iDynTree::RevoluteJoint * p =
            static_cast<iDynTree::RevoluteJoint*>(self);
        return p;
    }
SWIGINTERN iDynTree::FixedJoint *iDynTree_IJoint_asFixedJoint(iDynTree::IJoint *self){
        iDynTree::FixedJoint * p =
            static_cast<iDynTree::FixedJoint*>(self);
        return p;
    }

  namespace swig {
    template <>  struct traits< iDynTree::SolidShape > {
      typedef pointer_category category;
      static const char* type_name() { return"iDynTree::SolidShape"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< iDynTree::SolidShape*, std::allocator< iDynTree::SolidShape * > > > {
	  typedef value_category category;
	  static const char* type_name() {
	    return "std::vector<" "iDynTree::SolidShape" " *," "std::allocator< iDynTree::SolidShape * >" " >";
	  }
	};
      }
    
SWIGINTERN std::vector< iDynTree::SolidShape * >::value_type std_vector_Sl_iDynTree_SolidShape_Sm__Sg__pop(std::vector< iDynTree::SolidShape * > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN std::vector< iDynTree::SolidShape * >::value_type std_vector_Sl_iDynTree_SolidShape_Sm__Sg__brace(std::vector< iDynTree::SolidShape * > *self,std::vector< iDynTree::SolidShape * >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_iDynTree_SolidShape_Sm__Sg__setbrace(std::vector< iDynTree::SolidShape * > *self,std::vector< iDynTree::SolidShape * >::value_type x,std::vector< iDynTree::SolidShape * >::difference_type i){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN void std_vector_Sl_iDynTree_SolidShape_Sm__Sg__append(std::vector< iDynTree::SolidShape * > *self,std::vector< iDynTree::SolidShape * >::value_type x){
      self->push_back(x);
    }
SWIGINTERN std::vector< iDynTree::SolidShape * >::iterator std_vector_Sl_iDynTree_SolidShape_Sm__Sg__erase__SWIG_0(std::vector< iDynTree::SolidShape * > *self,std::vector< iDynTree::SolidShape * >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< iDynTree::SolidShape * >::iterator std_vector_Sl_iDynTree_SolidShape_Sm__Sg__erase__SWIG_1(std::vector< iDynTree::SolidShape * > *self,std::vector< iDynTree::SolidShape * >::iterator first,std::vector< iDynTree::SolidShape * >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< iDynTree::SolidShape * >::iterator std_vector_Sl_iDynTree_SolidShape_Sm__Sg__insert__SWIG_0(std::vector< iDynTree::SolidShape * > *self,std::vector< iDynTree::SolidShape * >::iterator pos,std::vector< iDynTree::SolidShape * >::value_type x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_iDynTree_SolidShape_Sm__Sg__insert__SWIG_1(std::vector< iDynTree::SolidShape * > *self,std::vector< iDynTree::SolidShape * >::iterator pos,std::vector< iDynTree::SolidShape * >::size_type n,std::vector< iDynTree::SolidShape * >::value_type x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >, std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >" "," "std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > >" " >";
	  }
	};
      }
    
SWIGINTERN std::vector< std::vector< iDynTree::SolidShape * > >::value_type std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__pop(std::vector< std::vector< iDynTree::SolidShape * > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN std::vector< std::vector< iDynTree::SolidShape * > >::value_type std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__brace(std::vector< std::vector< iDynTree::SolidShape * > > *self,std::vector< std::vector< iDynTree::SolidShape * > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__setbrace(std::vector< std::vector< iDynTree::SolidShape * > > *self,std::vector< std::vector< iDynTree::SolidShape * > >::value_type x,std::vector< std::vector< iDynTree::SolidShape * > >::difference_type i){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__append(std::vector< std::vector< iDynTree::SolidShape * > > *self,std::vector< std::vector< iDynTree::SolidShape * > >::value_type x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::vector< iDynTree::SolidShape * > >::iterator std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__erase__SWIG_0(std::vector< std::vector< iDynTree::SolidShape * > > *self,std::vector< std::vector< iDynTree::SolidShape * > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::vector< iDynTree::SolidShape * > >::iterator std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__erase__SWIG_1(std::vector< std::vector< iDynTree::SolidShape * > > *self,std::vector< std::vector< iDynTree::SolidShape * > >::iterator first,std::vector< std::vector< iDynTree::SolidShape * > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::vector< iDynTree::SolidShape * > >::iterator std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__insert__SWIG_0(std::vector< std::vector< iDynTree::SolidShape * > > *self,std::vector< std::vector< iDynTree::SolidShape * > >::iterator pos,std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__insert__SWIG_1(std::vector< std::vector< iDynTree::SolidShape * > > *self,std::vector< std::vector< iDynTree::SolidShape * > >::iterator pos,std::vector< std::vector< iDynTree::SolidShape * > >::size_type n,std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN iDynTree::SixAxisForceTorqueSensor *iDynTree_SensorsList_getSixAxisForceTorqueSensor(iDynTree::SensorsList const *self,int sensor_index){
        iDynTree::SixAxisForceTorqueSensor* p =
            static_cast<iDynTree::SixAxisForceTorqueSensor*>(self->getSensor(iDynTree::SIX_AXIS_FORCE_TORQUE,sensor_index));
        return p;
    }
SWIGINTERN iDynTree::AccelerometerSensor *iDynTree_SensorsList_getAccelerometerSensor(iDynTree::SensorsList const *self,int sensor_index){
        iDynTree::AccelerometerSensor* p =
            static_cast<iDynTree::AccelerometerSensor*>(self->getSensor(iDynTree::ACCELEROMETER,sensor_index));
        return p;
    }
SWIGINTERN iDynTree::GyroscopeSensor *iDynTree_SensorsList_getGyroscopeSensor(iDynTree::SensorsList const *self,int sensor_index){
        iDynTree::GyroscopeSensor* p =
            static_cast<iDynTree::GyroscopeSensor*>(self->getSensor(iDynTree::GYROSCOPE,sensor_index));
        return p;
    }
SWIGINTERN iDynTree::ThreeAxisAngularAccelerometerSensor *iDynTree_SensorsList_getThreeAxisAngularAccelerometerSensor(iDynTree::SensorsList const *self,int sensor_index){
        iDynTree::ThreeAxisAngularAccelerometerSensor* p =
            static_cast<iDynTree::ThreeAxisAngularAccelerometerSensor*>(self->getSensor(iDynTree::THREE_AXIS_ANGULAR_ACCELEROMETER,sensor_index));
        return p;
    }
SWIGINTERN iDynTree::ThreeAxisForceTorqueContactSensor *iDynTree_SensorsList_getThreeAxisForceTorqueContactSensor(iDynTree::SensorsList const *self,int sensor_index){
        iDynTree::ThreeAxisForceTorqueContactSensor* p =
            static_cast<iDynTree::ThreeAxisForceTorqueContactSensor*>(self->getSensor(iDynTree::THREE_AXIS_FORCE_TORQUE_CONTACT,sensor_index));
        return p;
    }

  namespace swig {
    template <>  struct traits< iDynTree::MatrixFixSize< 4,4 > > {
      typedef pointer_category category;
      static const char* type_name() { return"iDynTree::MatrixFixSize< 4,4 >"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< iDynTree::MatrixFixSize< 4,4 >, std::allocator< iDynTree::MatrixFixSize< 4,4 > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "iDynTree::MatrixFixSize< 4,4 >" "," "std::allocator< iDynTree::MatrixFixSize< 4,4 > >" " >";
	  }
	};
      }
    
SWIGINTERN std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type std_vector_Sl_iDynTree_Matrix4x4_Sg__pop(std::vector< iDynTree::Matrix4x4 > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< iDynTree::MatrixFixSize< 4,4 >,std::allocator< iDynTree::MatrixFixSize< 4,4 > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type std_vector_Sl_iDynTree_Matrix4x4_Sg__brace(std::vector< iDynTree::Matrix4x4 > *self,std::vector< iDynTree::MatrixFixSize< 4,4 > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_iDynTree_Matrix4x4_Sg__setbrace(std::vector< iDynTree::Matrix4x4 > *self,std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type x,std::vector< iDynTree::MatrixFixSize< 4,4 > >::difference_type i){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN void std_vector_Sl_iDynTree_Matrix4x4_Sg__append(std::vector< iDynTree::Matrix4x4 > *self,std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type x){
      self->push_back(x);
    }
SWIGINTERN std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator std_vector_Sl_iDynTree_Matrix4x4_Sg__erase__SWIG_0(std::vector< iDynTree::Matrix4x4 > *self,std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator std_vector_Sl_iDynTree_Matrix4x4_Sg__erase__SWIG_1(std::vector< iDynTree::Matrix4x4 > *self,std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator first,std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator std_vector_Sl_iDynTree_Matrix4x4_Sg__insert__SWIG_0(std::vector< iDynTree::Matrix4x4 > *self,std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator pos,std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_iDynTree_Matrix4x4_Sg__insert__SWIG_1(std::vector< iDynTree::Matrix4x4 > *self,std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator pos,std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type n,std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &x){ self->insert(pos, n, x); }
SWIGINTERN mxArray *std_vector_Sl_iDynTree_Matrix4x4_Sg__toMatlab(std::vector< iDynTree::Matrix4x4 > const *self){
        const mwSize NDIMS=3;
        mwSize nMatrices=self->size();
        std::vector<iDynTree::Matrix4x4> :: const_iterator it =self->begin();
        mwSize nRows=it->rows();
        mwSize nCols=it->cols();
        const mwSize dims[]={nMatrices,nRows,nCols};
        mxArray *p = mxCreateNumericArray(NDIMS,dims,mxDOUBLE_CLASS,mxREAL);
        double* d = static_cast<double*>(mxGetData(p));
        for (int matrixN = 0; matrixN < nMatrices; ++matrixN)
        {
            const double* content=it->data();
            for (int row = 0; row != nRows; ++row)
            {
                for (int col = 0; col != nCols; ++col)
                {
                    int index_sequence=(nCols*row + col);
                    size_t overall_index=matrixN+ nMatrices*(row +nRows* col);
                    d[overall_index]=content[index_sequence];
                }
            }
            
            ++it;
        }

        return p;


    }

#include <float.h>


#include <math.h>


/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
#ifndef SWIG_isfinite
/* isfinite() is a macro for C99, but a function in namespace std for C++11. */
# if defined(isfinite)
#  define SWIG_isfinite(X) (isfinite(X))
# elif defined __cplusplus && __cplusplus >= 201103L
#  define SWIG_isfinite(X) (std::isfinite(X))
# elif defined(_MSC_VER)
#  define SWIG_isfinite(X) (_finite(X))
# elif defined(__sun) && defined(__SVR4)
#  include <ieeefp.h>
#  define SWIG_isfinite(X) (finite(X))
# endif
#endif


/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
#ifdef SWIG_isfinite
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
#else
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
#endif


SWIGINTERN int
SWIG_AsVal_float (mxArray* obj, float *val)
{
  double v;
  int res = SWIG_AsVal_double (obj, &v);
  if (SWIG_IsOK(res)) {
    if (SWIG_Float_Overflow_Check(v)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< float >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE mxArray*
SWIG_From_float  (float value)
{    
  return SWIG_From_double  (value);
}

int _wrap_delete_MatlabSwigIterator(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_MatlabSwigIterator",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MatlabSwigIterator" "', argument " "1"" of type '" "swig::MatlabSwigIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_value(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_value",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_value" "', argument " "1"" of type '" "swig::MatlabSwigIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  try {
    result = (mxArray *)((swig::MatlabSwigIterator const *)arg1)->value();
  }
  catch(swig::stop_iteration &_e) {
    {
      SWIG_Error(SWIG_RuntimeError,"stop_iteration exception"); /* KT TODO */
      SWIG_fail;
    }
  }
  
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_incr__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  swig::MatlabSwigIterator *result = 0 ;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_incr",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_incr" "', argument " "1"" of type '" "swig::MatlabSwigIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatlabSwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  try {
    result = (swig::MatlabSwigIterator *)(arg1)->incr(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      SWIG_Error(SWIG_RuntimeError,"stop_iteration exception"); /* KT TODO */
      SWIG_fail;
    }
  }
  
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_incr__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  swig::MatlabSwigIterator *result = 0 ;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_incr",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_incr" "', argument " "1"" of type '" "swig::MatlabSwigIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  try {
    result = (swig::MatlabSwigIterator *)(arg1)->incr();
  }
  catch(swig::stop_iteration &_e) {
    {
      SWIG_Error(SWIG_RuntimeError,"stop_iteration exception"); /* KT TODO */
      SWIG_fail;
    }
  }
  
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_incr(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__MatlabSwigIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MatlabSwigIterator_incr__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__MatlabSwigIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MatlabSwigIterator_incr__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'MatlabSwigIterator_incr'."
    "  Possible C/C++ prototypes are:\n"
    "    swig::MatlabSwigIterator::incr(size_t)\n"
    "    swig::MatlabSwigIterator::incr()\n");
  return 1;
}


int _wrap_MatlabSwigIterator_decr__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  swig::MatlabSwigIterator *result = 0 ;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_decr",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_decr" "', argument " "1"" of type '" "swig::MatlabSwigIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatlabSwigIterator_decr" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  try {
    result = (swig::MatlabSwigIterator *)(arg1)->decr(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      SWIG_Error(SWIG_RuntimeError,"stop_iteration exception"); /* KT TODO */
      SWIG_fail;
    }
  }
  
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_decr__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  swig::MatlabSwigIterator *result = 0 ;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_decr",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_decr" "', argument " "1"" of type '" "swig::MatlabSwigIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  try {
    result = (swig::MatlabSwigIterator *)(arg1)->decr();
  }
  catch(swig::stop_iteration &_e) {
    {
      SWIG_Error(SWIG_RuntimeError,"stop_iteration exception"); /* KT TODO */
      SWIG_fail;
    }
  }
  
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_decr(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__MatlabSwigIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MatlabSwigIterator_decr__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__MatlabSwigIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MatlabSwigIterator_decr__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'MatlabSwigIterator_decr'."
    "  Possible C/C++ prototypes are:\n"
    "    swig::MatlabSwigIterator::decr(size_t)\n"
    "    swig::MatlabSwigIterator::decr()\n");
  return 1;
}


int _wrap_MatlabSwigIterator_distance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  swig::MatlabSwigIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  ptrdiff_t result;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_distance",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_distance" "', argument " "1"" of type '" "swig::MatlabSwigIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_swig__MatlabSwigIterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatlabSwigIterator_distance" "', argument " "2"" of type '" "swig::MatlabSwigIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatlabSwigIterator_distance" "', argument " "2"" of type '" "swig::MatlabSwigIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::MatlabSwigIterator * >(argp2);
  try {
    result = ((swig::MatlabSwigIterator const *)arg1)->distance((swig::MatlabSwigIterator const &)*arg2);
  }
  catch(std::invalid_argument &_e) {
    mexErrMsgIdAndTxt("SWIG:RuntimeError", "C++ side threw an exception of type " "std::invalid_argument"); SWIG_fail;
  }
  
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_equal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  swig::MatlabSwigIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_equal",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_equal" "', argument " "1"" of type '" "swig::MatlabSwigIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_swig__MatlabSwigIterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatlabSwigIterator_equal" "', argument " "2"" of type '" "swig::MatlabSwigIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatlabSwigIterator_equal" "', argument " "2"" of type '" "swig::MatlabSwigIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::MatlabSwigIterator * >(argp2);
  try {
    result = (bool)((swig::MatlabSwigIterator const *)arg1)->equal((swig::MatlabSwigIterator const &)*arg2);
  }
  catch(std::invalid_argument &_e) {
    mexErrMsgIdAndTxt("SWIG:RuntimeError", "C++ side threw an exception of type " "std::invalid_argument"); SWIG_fail;
  }
  
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_copy(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  swig::MatlabSwigIterator *result = 0 ;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_copy",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_copy" "', argument " "1"" of type '" "swig::MatlabSwigIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  result = (swig::MatlabSwigIterator *)((swig::MatlabSwigIterator const *)arg1)->copy();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__MatlabSwigIterator, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_next(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_next",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_next" "', argument " "1"" of type '" "swig::MatlabSwigIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  try {
    result = (mxArray *)(arg1)->next();
  }
  catch(swig::stop_iteration &_e) {
    {
      SWIG_Error(SWIG_RuntimeError,"stop_iteration exception"); /* KT TODO */
      SWIG_fail;
    }
  }
  
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_previous(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_previous",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_previous" "', argument " "1"" of type '" "swig::MatlabSwigIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  try {
    result = (mxArray *)(arg1)->previous();
  }
  catch(swig::stop_iteration &_e) {
    {
      SWIG_Error(SWIG_RuntimeError,"stop_iteration exception"); /* KT TODO */
      SWIG_fail;
    }
  }
  
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_advance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  swig::MatlabSwigIterator *result = 0 ;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_advance",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_advance" "', argument " "1"" of type '" "swig::MatlabSwigIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatlabSwigIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::MatlabSwigIterator *)(arg1)->advance(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      SWIG_Error(SWIG_RuntimeError,"stop_iteration exception"); /* KT TODO */
      SWIG_fail;
    }
  }
  
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_eq(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  swig::MatlabSwigIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_eq",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_eq" "', argument " "1"" of type '" "swig::MatlabSwigIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_swig__MatlabSwigIterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatlabSwigIterator_eq" "', argument " "2"" of type '" "swig::MatlabSwigIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatlabSwigIterator_eq" "', argument " "2"" of type '" "swig::MatlabSwigIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::MatlabSwigIterator * >(argp2);
  result = (bool)((swig::MatlabSwigIterator const *)arg1)->operator ==((swig::MatlabSwigIterator const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_ne(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  swig::MatlabSwigIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_ne",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_ne" "', argument " "1"" of type '" "swig::MatlabSwigIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_swig__MatlabSwigIterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatlabSwigIterator_ne" "', argument " "2"" of type '" "swig::MatlabSwigIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatlabSwigIterator_ne" "', argument " "2"" of type '" "swig::MatlabSwigIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::MatlabSwigIterator * >(argp2);
  result = (bool)((swig::MatlabSwigIterator const *)arg1)->operator !=((swig::MatlabSwigIterator const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_TODOincr(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  swig::MatlabSwigIterator *result = 0 ;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_TODOincr",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_TODOincr" "', argument " "1"" of type '" "swig::MatlabSwigIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  result = (swig::MatlabSwigIterator *)(arg1)->operator ++();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_TODOdecr(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  swig::MatlabSwigIterator *result = 0 ;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_TODOdecr",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_TODOdecr" "', argument " "1"" of type '" "swig::MatlabSwigIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  result = (swig::MatlabSwigIterator *)(arg1)->operator --();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_plus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  swig::MatlabSwigIterator *result = 0 ;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_plus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_plus" "', argument " "1"" of type '" "swig::MatlabSwigIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatlabSwigIterator_plus" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::MatlabSwigIterator *)((swig::MatlabSwigIterator const *)arg1)->operator +(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      SWIG_Error(SWIG_RuntimeError,"stop_iteration exception"); /* KT TODO */
      SWIG_fail;
    }
  }
  
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__MatlabSwigIterator, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_minus__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  swig::MatlabSwigIterator *result = 0 ;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_minus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_minus" "', argument " "1"" of type '" "swig::MatlabSwigIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatlabSwigIterator_minus" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::MatlabSwigIterator *)((swig::MatlabSwigIterator const *)arg1)->operator -(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      SWIG_Error(SWIG_RuntimeError,"stop_iteration exception"); /* KT TODO */
      SWIG_fail;
    }
  }
  
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__MatlabSwigIterator, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_minus__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  swig::MatlabSwigIterator *arg1 = (swig::MatlabSwigIterator *) 0 ;
  swig::MatlabSwigIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  ptrdiff_t result;
  
  if (!SWIG_check_num_args("MatlabSwigIterator_minus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_swig__MatlabSwigIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatlabSwigIterator_minus" "', argument " "1"" of type '" "swig::MatlabSwigIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::MatlabSwigIterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_swig__MatlabSwigIterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatlabSwigIterator_minus" "', argument " "2"" of type '" "swig::MatlabSwigIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatlabSwigIterator_minus" "', argument " "2"" of type '" "swig::MatlabSwigIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::MatlabSwigIterator * >(argp2);
  result = ((swig::MatlabSwigIterator const *)arg1)->operator -((swig::MatlabSwigIterator const &)*arg2);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatlabSwigIterator_minus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__MatlabSwigIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_swig__MatlabSwigIterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MatlabSwigIterator_minus__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__MatlabSwigIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MatlabSwigIterator_minus__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'MatlabSwigIterator_minus'."
    "  Possible C/C++ prototypes are:\n"
    "    swig::MatlabSwigIterator::operator -(ptrdiff_t) const\n"
    "    swig::MatlabSwigIterator::operator -(swig::MatlabSwigIterator const &) const\n");
  return 1;
}


int _wrap_StringVector_pop(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::string >::value_type result;
  
  if (!SWIG_check_num_args("StringVector_pop",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_pop" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  try {
    result = std_vector_Sl_std_string_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_brace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::vector< std::string >::value_type result;
  
  if (!SWIG_check_num_args("StringVector_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_brace" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector_brace" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  try {
    result = std_vector_Sl_std_string_Sg__brace(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_setbrace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("StringVector_setbrace",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_setbrace" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "StringVector_setbrace" "', argument " "2"" of type '" "std::vector< std::string >::value_type""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringVector_setbrace" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  try {
    std_vector_Sl_std_string_Sg__setbrace(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_append(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("StringVector_append",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_append" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "StringVector_append" "', argument " "2"" of type '" "std::vector< std::string >::value_type""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  std_vector_Sl_std_string_Sg__append(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_StringVector__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  std::vector< std::string > *result = 0 ;
  
  if (!SWIG_check_num_args("new_StringVector",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (std::vector< std::string > *)new std::vector< std::string >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_StringVector__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  mxArray * _out;
  std::vector< std::string > *result = 0 ;
  
  if (!SWIG_check_num_args("new_StringVector",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res1 = swig::asptr(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StringVector" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StringVector" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 0;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 1;
}


int _wrap_StringVector_empty(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("StringVector_empty",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_empty" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (bool)((std::vector< std::string > const *)arg1)->empty();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::string >::size_type result;
  
  if (!SWIG_check_num_args("StringVector_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_size" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = ((std::vector< std::string > const *)arg1)->size();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_swap(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("StringVector_swap",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_swap" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringVector_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringVector_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
  (arg1)->swap(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_begin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::string >::iterator result;
  
  if (!SWIG_check_num_args("StringVector_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_begin" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (arg1)->begin();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_end(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::string >::iterator result;
  
  if (!SWIG_check_num_args("StringVector_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_end" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (arg1)->end();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_rbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::string >::reverse_iterator result;
  
  if (!SWIG_check_num_args("StringVector_rbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_rbegin" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (arg1)->rbegin();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::reverse_iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_rend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::string >::reverse_iterator result;
  
  if (!SWIG_check_num_args("StringVector_rend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_rend" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (arg1)->rend();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::reverse_iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_clear(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("StringVector_clear",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_clear" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  (arg1)->clear();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_get_allocator(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< std::allocator< std::string > > result;
  
  if (!SWIG_check_num_args("StringVector_get_allocator",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_get_allocator" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = ((std::vector< std::string > const *)arg1)->get_allocator();
  _out = SWIG_NewPointerObj((new std::vector< std::string >::allocator_type(static_cast< const std::vector< std::string >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_StringVector__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  std::vector< std::string > *result = 0 ;
  
  if (!SWIG_check_num_args("new_StringVector",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringVector" "', argument " "1"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::string >::size_type >(val1);
  result = (std::vector< std::string > *)new std::vector< std::string >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_pop_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("StringVector_pop_back",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_pop_back" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  (arg1)->pop_back();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("StringVector_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_resize" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_erase__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  mxArray * _out;
  std::vector< std::string >::iterator result;
  
  if (!SWIG_check_num_args("StringVector_erase",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_erase" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  result = std_vector_Sl_std_string_Sg__erase__SWIG_0(arg1,arg2);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_erase__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  swig::MatlabSwigIterator *iter3 = 0 ;
  int res3 ;
  mxArray * _out;
  std::vector< std::string >::iterator result;
  
  if (!SWIG_check_num_args("StringVector_erase",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_erase" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter3), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "3"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "3"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  result = std_vector_Sl_std_string_Sg__erase__SWIG_1(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_erase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_StringVector_erase__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        swig::MatlabSwigIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_StringVector_erase__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'StringVector_erase'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::erase(std::vector< std::string >::iterator)\n"
    "    std::vector< std::string >::erase(std::vector< std::string >::iterator,std::vector< std::string >::iterator)\n");
  return 1;
}


int _wrap_new_StringVector__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string >::size_type arg1 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  std::vector< std::string > *result = 0 ;
  
  if (!SWIG_check_num_args("new_StringVector",argc,2,2,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringVector" "', argument " "1"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::string >::size_type >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_StringVector" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_StringVector" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (std::vector< std::string > *)new std::vector< std::string >(arg1,(std::vector< std::string >::value_type const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_new_StringVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_StringVector__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_StringVector__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StringVector__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_StringVector__SWIG_3(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_StringVector'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::vector()\n"
    "    std::vector< std::string >::vector(std::vector< std::string > const &)\n"
    "    std::vector< std::string >::vector(std::vector< std::string >::size_type)\n"
    "    std::vector< std::string >::vector(std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 1;
}


int _wrap_StringVector_push_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("StringVector_push_back",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_push_back" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringVector_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringVector_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_StringVector_front(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::string >::value_type *result = 0 ;
  
  if (!SWIG_check_num_args("StringVector_front",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_front" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->front();
  _out = SWIG_From_std_string(static_cast< std::string >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::string >::value_type *result = 0 ;
  
  if (!SWIG_check_num_args("StringVector_back",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_back" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->back();
  _out = SWIG_From_std_string(static_cast< std::string >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_assign(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("StringVector_assign",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_assign" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector_assign" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringVector_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringVector_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->assign(arg2,(std::vector< std::string >::value_type const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_StringVector_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("StringVector_resize",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_resize" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringVector_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringVector_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->resize(arg2,(std::vector< std::string >::value_type const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_StringVector_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringVector_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringVector_resize__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'StringVector_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::resize(std::vector< std::string >::size_type)\n"
    "    std::vector< std::string >::resize(std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 1;
}


int _wrap_StringVector_insert__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  std::vector< std::string >::iterator result;
  
  if (!SWIG_check_num_args("StringVector_insert",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_insert" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringVector_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringVector_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  result = std_vector_Sl_std_string_Sg__insert__SWIG_0(arg1,arg2,(std::string const &)*arg3);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_StringVector_insert__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::size_type arg3 ;
  std::vector< std::string >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("StringVector_insert",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_insert" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringVector_insert" "', argument " "3"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::size_type >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringVector_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "StringVector_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  std_vector_Sl_std_string_Sg__insert__SWIG_1(arg1,arg2,arg3,(std::string const &)*arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return 0;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return 1;
}


int _wrap_StringVector_insert(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringVector_insert__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StringVector_insert__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'StringVector_insert'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::insert(std::vector< std::string >::iterator,std::vector< std::string >::value_type const &)\n"
    "    std::vector< std::string >::insert(std::vector< std::string >::iterator,std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 1;
}


int _wrap_StringVector_reserve(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("StringVector_reserve",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_reserve" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector_reserve" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  (arg1)->reserve(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_StringVector_capacity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::string >::size_type result;
  
  if (!SWIG_check_num_args("StringVector_capacity",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_capacity" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  result = ((std::vector< std::string > const *)arg1)->capacity();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_StringVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_StringVector",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringVector" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_pop(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< int >::value_type result;
  
  if (!SWIG_check_num_args("IntVector_pop",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_pop" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  try {
    result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_brace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::vector< int >::value_type result;
  
  if (!SWIG_check_num_args("IntVector_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_brace" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_brace" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  try {
    result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__brace(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_setbrace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::value_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IntVector_setbrace",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_setbrace" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_setbrace" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
  } 
  arg2 = static_cast< std::vector< int >::value_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_setbrace" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  try {
    std_vector_Sl_int_Sg__setbrace(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_append(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IntVector_append",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_append" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
  } 
  arg2 = static_cast< std::vector< int >::value_type >(val2);
  std_vector_Sl_int_Sg__append(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_IntVector__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  std::vector< int > *result = 0 ;
  
  if (!SWIG_check_num_args("new_IntVector",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (std::vector< int > *)new std::vector< int >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_IntVector__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  mxArray * _out;
  std::vector< int > *result = 0 ;
  
  if (!SWIG_check_num_args("new_IntVector",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res1 = swig::asptr(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 0;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 1;
}


int _wrap_IntVector_empty(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IntVector_empty",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_empty" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (bool)((std::vector< int > const *)arg1)->empty();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< int >::size_type result;
  
  if (!SWIG_check_num_args("IntVector_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_size" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = ((std::vector< int > const *)arg1)->size();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_swap(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IntVector_swap",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_swap" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntVector_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IntVector_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int > * >(argp2);
  (arg1)->swap(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_begin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< int >::iterator result;
  
  if (!SWIG_check_num_args("IntVector_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_begin" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (arg1)->begin();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_end(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< int >::iterator result;
  
  if (!SWIG_check_num_args("IntVector_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_end" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (arg1)->end();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_rbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< int >::reverse_iterator result;
  
  if (!SWIG_check_num_args("IntVector_rbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_rbegin" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (arg1)->rbegin();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_rend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< int >::reverse_iterator result;
  
  if (!SWIG_check_num_args("IntVector_rend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_rend" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (arg1)->rend();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_clear(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IntVector_clear",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  (arg1)->clear();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_get_allocator(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< std::allocator< int > > result;
  
  if (!SWIG_check_num_args("IntVector_get_allocator",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_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();
  _out = SWIG_NewPointerObj((new std::vector< int >::allocator_type(static_cast< const std::vector< int >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_IntVector__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  std::vector< int > *result = 0 ;
  
  if (!SWIG_check_num_args("new_IntVector",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntVector" "', 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);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_pop_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IntVector_pop_back",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  (arg1)->pop_back();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IntVector_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_erase__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  mxArray * _out;
  std::vector< int >::iterator result;
  
  if (!SWIG_check_num_args("IntVector_erase",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  result = std_vector_Sl_int_Sg__erase__SWIG_0(arg1,arg2);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_erase__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::iterator arg2 ;
  std::vector< int >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  swig::MatlabSwigIterator *iter3 = 0 ;
  int res3 ;
  mxArray * _out;
  std::vector< int >::iterator result;
  
  if (!SWIG_check_num_args("IntVector_erase",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter3), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< int >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
    }
  }
  result = std_vector_Sl_int_Sg__erase__SWIG_1(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_erase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_IntVector_erase__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        swig::MatlabSwigIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_IntVector_erase__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'IntVector_erase'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::erase(std::vector< int >::iterator)\n"
    "    std::vector< int >::erase(std::vector< int >::iterator,std::vector< int >::iterator)\n");
  return 1;
}


int _wrap_new_IntVector__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int >::size_type arg1 ;
  std::vector< int >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< int >::value_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::vector< int > *result = 0 ;
  
  if (!SWIG_check_num_args("new_IntVector",argc,2,2,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< int >::size_type >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IntVector" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
  } 
  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);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_IntVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_IntVector__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_IntVector__SWIG_2(resc,resv,argc,argv);
    }
  }
  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_new_IntVector__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_IntVector__SWIG_3(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_IntVector'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::vector()\n"
    "    std::vector< int >::vector(std::vector< int > const &)\n"
    "    std::vector< int >::vector(std::vector< int >::size_type)\n"
    "    std::vector< int >::vector(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
  return 1;
}


int _wrap_IntVector_push_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  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 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IntVector_push_back",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_push_back" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< int >::value_type >(val2);
  arg2 = &temp2;
  (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_front(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< int >::value_type *result = 0 ;
  
  if (!SWIG_check_num_args("IntVector_front",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_front" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->front();
  _out = SWIG_From_int(static_cast< int >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< int >::value_type *result = 0 ;
  
  if (!SWIG_check_num_args("IntVector_back",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_back" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->back();
  _out = SWIG_From_int(static_cast< int >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_assign(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  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 ;
  int val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IntVector_assign",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_assign" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  (arg1)->assign(arg2,(std::vector< int >::value_type const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  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 ;
  int val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IntVector_resize",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  (arg1)->resize(arg2,(std::vector< int >::value_type const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IntVector_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_IntVector_resize__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'IntVector_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::resize(std::vector< int >::size_type)\n"
    "    std::vector< int >::resize(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
  return 1;
}


int _wrap_IntVector_insert__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::iterator arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  std::vector< int >::iterator result;
  
  if (!SWIG_check_num_args("IntVector_insert",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  result = std_vector_Sl_int_Sg__insert__SWIG_0(arg1,arg2,(int const &)*arg3);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_insert__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  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::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::vector< int >::value_type temp4 ;
  int val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IntVector_insert",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'");
  } 
  arg3 = static_cast< std::vector< int >::size_type >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IntVector_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'");
  } 
  temp4 = static_cast< std::vector< int >::value_type >(val4);
  arg4 = &temp4;
  std_vector_Sl_int_Sg__insert__SWIG_1(arg1,arg2,arg3,(int const &)*arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_insert(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_IntVector_insert__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_IntVector_insert__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'IntVector_insert'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::value_type const &)\n"
    "    std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
  return 1;
}


int _wrap_IntVector_reserve(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IntVector_reserve",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_reserve" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  (arg1)->reserve(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IntVector_capacity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< int >::size_type result;
  
  if (!SWIG_check_num_args("IntVector_capacity",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &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 '" "IntVector_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  result = ((std::vector< int > const *)arg1)->capacity();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_IntVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_IntVector",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &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_IntVector" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_pop(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor >::value_type result;
  
  if (!SWIG_check_num_args("BerdySensors_pop",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_pop" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  try {
    result = std_vector_Sl_iDynTree_BerdySensor_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = SWIG_NewPointerObj((new std::vector< iDynTree::BerdySensor >::value_type(static_cast< const std::vector< iDynTree::BerdySensor >::value_type& >(result))), SWIGTYPE_p_iDynTree__BerdySensor, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_brace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  std::vector< iDynTree::BerdySensor >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor >::value_type result;
  
  if (!SWIG_check_num_args("BerdySensors_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_brace" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdySensors_brace" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::BerdySensor >::difference_type >(val2);
  try {
    result = std_vector_Sl_iDynTree_BerdySensor_Sg__brace(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = SWIG_NewPointerObj((new std::vector< iDynTree::BerdySensor >::value_type(static_cast< const std::vector< iDynTree::BerdySensor >::value_type& >(result))), SWIGTYPE_p_iDynTree__BerdySensor, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_setbrace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  std::vector< iDynTree::BerdySensor >::value_type arg2 ;
  std::vector< iDynTree::BerdySensor >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySensors_setbrace",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_setbrace" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__BerdySensor,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySensors_setbrace" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::value_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySensors_setbrace" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::value_type""'");
    } else {
      arg2 = *(reinterpret_cast< std::vector< iDynTree::BerdySensor >::value_type * >(argp2));
    }
  }
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BerdySensors_setbrace" "', argument " "3"" of type '" "std::vector< iDynTree::BerdySensor >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< iDynTree::BerdySensor >::difference_type >(val3);
  try {
    std_vector_Sl_iDynTree_BerdySensor_Sg__setbrace(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_append(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  std::vector< iDynTree::BerdySensor >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySensors_append",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_append" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__BerdySensor,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySensors_append" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::value_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySensors_append" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::value_type""'");
    } else {
      arg2 = *(reinterpret_cast< std::vector< iDynTree::BerdySensor >::value_type * >(argp2));
    }
  }
  std_vector_Sl_iDynTree_BerdySensor_Sg__append(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_BerdySensors__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  std::vector< iDynTree::BerdySensor > *result = 0 ;
  
  if (!SWIG_check_num_args("new_BerdySensors",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (std::vector< iDynTree::BerdySensor > *)new std::vector< iDynTree::BerdySensor >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_BerdySensors__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor > *result = 0 ;
  
  if (!SWIG_check_num_args("new_BerdySensors",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    std::vector< iDynTree::BerdySensor,std::allocator< iDynTree::BerdySensor > > *ptr = (std::vector< iDynTree::BerdySensor,std::allocator< iDynTree::BerdySensor > > *)0;
    res1 = swig::asptr(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BerdySensors" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BerdySensors" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< iDynTree::BerdySensor > *)new std::vector< iDynTree::BerdySensor >((std::vector< iDynTree::BerdySensor > const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 0;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 1;
}


int _wrap_BerdySensors_empty(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdySensors_empty",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_empty" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  result = (bool)((std::vector< iDynTree::BerdySensor > const *)arg1)->empty();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor >::size_type result;
  
  if (!SWIG_check_num_args("BerdySensors_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_size" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  result = ((std::vector< iDynTree::BerdySensor > const *)arg1)->size();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_swap(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  std::vector< iDynTree::BerdySensor > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySensors_swap",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_swap" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySensors_swap" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySensors_swap" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp2);
  (arg1)->swap(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_begin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor >::iterator result;
  
  if (!SWIG_check_num_args("BerdySensors_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_begin" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  result = (arg1)->begin();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::BerdySensor >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_end(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor >::iterator result;
  
  if (!SWIG_check_num_args("BerdySensors_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_end" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  result = (arg1)->end();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::BerdySensor >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_rbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor >::reverse_iterator result;
  
  if (!SWIG_check_num_args("BerdySensors_rbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_rbegin" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  result = (arg1)->rbegin();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::BerdySensor >::reverse_iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_rend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor >::reverse_iterator result;
  
  if (!SWIG_check_num_args("BerdySensors_rend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_rend" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  result = (arg1)->rend();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::BerdySensor >::reverse_iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_clear(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySensors_clear",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_clear" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  (arg1)->clear();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_get_allocator(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< std::allocator< iDynTree::BerdySensor > > result;
  
  if (!SWIG_check_num_args("BerdySensors_get_allocator",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_get_allocator" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  result = ((std::vector< iDynTree::BerdySensor > const *)arg1)->get_allocator();
  _out = SWIG_NewPointerObj((new std::vector< iDynTree::BerdySensor >::allocator_type(static_cast< const std::vector< iDynTree::BerdySensor >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_iDynTree__BerdySensor_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_BerdySensors__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor > *result = 0 ;
  
  if (!SWIG_check_num_args("new_BerdySensors",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BerdySensors" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor >::size_type""'");
  } 
  arg1 = static_cast< std::vector< iDynTree::BerdySensor >::size_type >(val1);
  result = (std::vector< iDynTree::BerdySensor > *)new std::vector< iDynTree::BerdySensor >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_pop_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySensors_pop_back",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_pop_back" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  (arg1)->pop_back();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  std::vector< iDynTree::BerdySensor >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySensors_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_resize" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdySensors_resize" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::BerdySensor >::size_type >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_erase__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  std::vector< iDynTree::BerdySensor >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor >::iterator result;
  
  if (!SWIG_check_num_args("BerdySensors_erase",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_erase" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdySensors_erase" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdySensors_erase" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::iterator""'");
    }
  }
  result = std_vector_Sl_iDynTree_BerdySensor_Sg__erase__SWIG_0(arg1,arg2);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::BerdySensor >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_erase__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  std::vector< iDynTree::BerdySensor >::iterator arg2 ;
  std::vector< iDynTree::BerdySensor >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  swig::MatlabSwigIterator *iter3 = 0 ;
  int res3 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor >::iterator result;
  
  if (!SWIG_check_num_args("BerdySensors_erase",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_erase" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdySensors_erase" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdySensors_erase" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter3), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdySensors_erase" "', argument " "3"" of type '" "std::vector< iDynTree::BerdySensor >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdySensors_erase" "', argument " "3"" of type '" "std::vector< iDynTree::BerdySensor >::iterator""'");
    }
  }
  result = std_vector_Sl_iDynTree_BerdySensor_Sg__erase__SWIG_1(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::BerdySensor >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_erase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::BerdySensor,std::allocator< iDynTree::BerdySensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_BerdySensors_erase__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::BerdySensor,std::allocator< iDynTree::BerdySensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *>(iter) != 0));
      if (_v) {
        swig::MatlabSwigIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_BerdySensors_erase__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdySensors_erase'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::BerdySensor >::erase(std::vector< iDynTree::BerdySensor >::iterator)\n"
    "    std::vector< iDynTree::BerdySensor >::erase(std::vector< iDynTree::BerdySensor >::iterator,std::vector< iDynTree::BerdySensor >::iterator)\n");
  return 1;
}


int _wrap_new_BerdySensors__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor >::size_type arg1 ;
  std::vector< iDynTree::BerdySensor >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor > *result = 0 ;
  
  if (!SWIG_check_num_args("new_BerdySensors",argc,2,2,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BerdySensors" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor >::size_type""'");
  } 
  arg1 = static_cast< std::vector< iDynTree::BerdySensor >::size_type >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__BerdySensor,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BerdySensors" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BerdySensors" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::BerdySensor >::value_type * >(argp2);
  result = (std::vector< iDynTree::BerdySensor > *)new std::vector< iDynTree::BerdySensor >(arg1,(std::vector< iDynTree::BerdySensor >::value_type const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_BerdySensors(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_BerdySensors__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_BerdySensors__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::BerdySensor,std::allocator< iDynTree::BerdySensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BerdySensors__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__BerdySensor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BerdySensors__SWIG_3(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_BerdySensors'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::BerdySensor >::vector()\n"
    "    std::vector< iDynTree::BerdySensor >::vector(std::vector< iDynTree::BerdySensor > const &)\n"
    "    std::vector< iDynTree::BerdySensor >::vector(std::vector< iDynTree::BerdySensor >::size_type)\n"
    "    std::vector< iDynTree::BerdySensor >::vector(std::vector< iDynTree::BerdySensor >::size_type,std::vector< iDynTree::BerdySensor >::value_type const &)\n");
  return 1;
}


int _wrap_BerdySensors_push_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  std::vector< iDynTree::BerdySensor >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySensors_push_back",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_push_back" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__BerdySensor,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySensors_push_back" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySensors_push_back" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::BerdySensor >::value_type * >(argp2);
  (arg1)->push_back((std::vector< iDynTree::BerdySensor >::value_type const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_front(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor >::value_type *result = 0 ;
  
  if (!SWIG_check_num_args("BerdySensors_front",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_front" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  result = (std::vector< iDynTree::BerdySensor >::value_type *) &((std::vector< iDynTree::BerdySensor > const *)arg1)->front();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__BerdySensor, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor >::value_type *result = 0 ;
  
  if (!SWIG_check_num_args("BerdySensors_back",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_back" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  result = (std::vector< iDynTree::BerdySensor >::value_type *) &((std::vector< iDynTree::BerdySensor > const *)arg1)->back();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__BerdySensor, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_assign(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  std::vector< iDynTree::BerdySensor >::size_type arg2 ;
  std::vector< iDynTree::BerdySensor >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySensors_assign",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_assign" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdySensors_assign" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::BerdySensor >::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__BerdySensor,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdySensors_assign" "', argument " "3"" of type '" "std::vector< iDynTree::BerdySensor >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySensors_assign" "', argument " "3"" of type '" "std::vector< iDynTree::BerdySensor >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< iDynTree::BerdySensor >::value_type * >(argp3);
  (arg1)->assign(arg2,(std::vector< iDynTree::BerdySensor >::value_type const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  std::vector< iDynTree::BerdySensor >::size_type arg2 ;
  std::vector< iDynTree::BerdySensor >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySensors_resize",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_resize" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdySensors_resize" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::BerdySensor >::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__BerdySensor,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdySensors_resize" "', argument " "3"" of type '" "std::vector< iDynTree::BerdySensor >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySensors_resize" "', argument " "3"" of type '" "std::vector< iDynTree::BerdySensor >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< iDynTree::BerdySensor >::value_type * >(argp3);
  (arg1)->resize(arg2,(std::vector< iDynTree::BerdySensor >::value_type const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::BerdySensor,std::allocator< iDynTree::BerdySensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BerdySensors_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::BerdySensor,std::allocator< iDynTree::BerdySensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__BerdySensor, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BerdySensors_resize__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdySensors_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::BerdySensor >::resize(std::vector< iDynTree::BerdySensor >::size_type)\n"
    "    std::vector< iDynTree::BerdySensor >::resize(std::vector< iDynTree::BerdySensor >::size_type,std::vector< iDynTree::BerdySensor >::value_type const &)\n");
  return 1;
}


int _wrap_BerdySensors_insert__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  std::vector< iDynTree::BerdySensor >::iterator arg2 ;
  std::vector< iDynTree::BerdySensor >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor >::iterator result;
  
  if (!SWIG_check_num_args("BerdySensors_insert",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_insert" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdySensors_insert" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdySensors_insert" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__BerdySensor,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdySensors_insert" "', argument " "3"" of type '" "std::vector< iDynTree::BerdySensor >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySensors_insert" "', argument " "3"" of type '" "std::vector< iDynTree::BerdySensor >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< iDynTree::BerdySensor >::value_type * >(argp3);
  result = std_vector_Sl_iDynTree_BerdySensor_Sg__insert__SWIG_0(arg1,arg2,(iDynTree::BerdySensor const &)*arg3);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::BerdySensor >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_insert__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  std::vector< iDynTree::BerdySensor >::iterator arg2 ;
  std::vector< iDynTree::BerdySensor >::size_type arg3 ;
  std::vector< iDynTree::BerdySensor >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySensors_insert",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_insert" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdySensors_insert" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdySensors_insert" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BerdySensors_insert" "', argument " "3"" of type '" "std::vector< iDynTree::BerdySensor >::size_type""'");
  } 
  arg3 = static_cast< std::vector< iDynTree::BerdySensor >::size_type >(val3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__BerdySensor,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BerdySensors_insert" "', argument " "4"" of type '" "std::vector< iDynTree::BerdySensor >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySensors_insert" "', argument " "4"" of type '" "std::vector< iDynTree::BerdySensor >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< iDynTree::BerdySensor >::value_type * >(argp4);
  std_vector_Sl_iDynTree_BerdySensor_Sg__insert__SWIG_1(arg1,arg2,arg3,(iDynTree::BerdySensor const &)*arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_insert(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::BerdySensor,std::allocator< iDynTree::BerdySensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *>(iter) != 0));
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__BerdySensor, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BerdySensors_insert__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::BerdySensor,std::allocator< iDynTree::BerdySensor > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdySensor >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__BerdySensor, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_BerdySensors_insert__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdySensors_insert'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::BerdySensor >::insert(std::vector< iDynTree::BerdySensor >::iterator,std::vector< iDynTree::BerdySensor >::value_type const &)\n"
    "    std::vector< iDynTree::BerdySensor >::insert(std::vector< iDynTree::BerdySensor >::iterator,std::vector< iDynTree::BerdySensor >::size_type,std::vector< iDynTree::BerdySensor >::value_type const &)\n");
  return 1;
}


int _wrap_BerdySensors_reserve(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  std::vector< iDynTree::BerdySensor >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySensors_reserve",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_reserve" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdySensors_reserve" "', argument " "2"" of type '" "std::vector< iDynTree::BerdySensor >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::BerdySensor >::size_type >(val2);
  (arg1)->reserve(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensors_capacity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor >::size_type result;
  
  if (!SWIG_check_num_args("BerdySensors_capacity",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensors_capacity" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  result = ((std::vector< iDynTree::BerdySensor > const *)arg1)->capacity();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_BerdySensors(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdySensor > *arg1 = (std::vector< iDynTree::BerdySensor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_BerdySensors",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BerdySensors" "', argument " "1"" of type '" "std::vector< iDynTree::BerdySensor > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdySensor > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_pop(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable >::value_type result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_pop",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_pop" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  try {
    result = std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = SWIG_NewPointerObj((new std::vector< iDynTree::BerdyDynamicVariable >::value_type(static_cast< const std::vector< iDynTree::BerdyDynamicVariable >::value_type& >(result))), SWIGTYPE_p_iDynTree__BerdyDynamicVariable, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_brace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  std::vector< iDynTree::BerdyDynamicVariable >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable >::value_type result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_brace" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyDynamicVariables_brace" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::BerdyDynamicVariable >::difference_type >(val2);
  try {
    result = std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__brace(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = SWIG_NewPointerObj((new std::vector< iDynTree::BerdyDynamicVariable >::value_type(static_cast< const std::vector< iDynTree::BerdyDynamicVariable >::value_type& >(result))), SWIGTYPE_p_iDynTree__BerdyDynamicVariable, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_setbrace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  std::vector< iDynTree::BerdyDynamicVariable >::value_type arg2 ;
  std::vector< iDynTree::BerdyDynamicVariable >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_setbrace",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_setbrace" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__BerdyDynamicVariable,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyDynamicVariables_setbrace" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyDynamicVariables_setbrace" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type""'");
    } else {
      arg2 = *(reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable >::value_type * >(argp2));
    }
  }
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BerdyDynamicVariables_setbrace" "', argument " "3"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< iDynTree::BerdyDynamicVariable >::difference_type >(val3);
  try {
    std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__setbrace(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_append(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  std::vector< iDynTree::BerdyDynamicVariable >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_append",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_append" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__BerdyDynamicVariable,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyDynamicVariables_append" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyDynamicVariables_append" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type""'");
    } else {
      arg2 = *(reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable >::value_type * >(argp2));
    }
  }
  std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__append(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_BerdyDynamicVariables__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable > *result = 0 ;
  
  if (!SWIG_check_num_args("new_BerdyDynamicVariables",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (std::vector< iDynTree::BerdyDynamicVariable > *)new std::vector< iDynTree::BerdyDynamicVariable >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_BerdyDynamicVariables__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable > *result = 0 ;
  
  if (!SWIG_check_num_args("new_BerdyDynamicVariables",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    std::vector< iDynTree::BerdyDynamicVariable,std::allocator< iDynTree::BerdyDynamicVariable > > *ptr = (std::vector< iDynTree::BerdyDynamicVariable,std::allocator< iDynTree::BerdyDynamicVariable > > *)0;
    res1 = swig::asptr(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BerdyDynamicVariables" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BerdyDynamicVariables" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< iDynTree::BerdyDynamicVariable > *)new std::vector< iDynTree::BerdyDynamicVariable >((std::vector< iDynTree::BerdyDynamicVariable > const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 0;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 1;
}


int _wrap_BerdyDynamicVariables_empty(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_empty",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_empty" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  result = (bool)((std::vector< iDynTree::BerdyDynamicVariable > const *)arg1)->empty();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable >::size_type result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_size" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  result = ((std::vector< iDynTree::BerdyDynamicVariable > const *)arg1)->size();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_swap(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  std::vector< iDynTree::BerdyDynamicVariable > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_swap",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_swap" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyDynamicVariables_swap" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyDynamicVariables_swap" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp2);
  (arg1)->swap(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_begin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable >::iterator result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_begin" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  result = (arg1)->begin();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::BerdyDynamicVariable >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_end(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable >::iterator result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_end" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  result = (arg1)->end();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::BerdyDynamicVariable >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_rbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable >::reverse_iterator result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_rbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_rbegin" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  result = (arg1)->rbegin();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::BerdyDynamicVariable >::reverse_iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_rend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable >::reverse_iterator result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_rend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_rend" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  result = (arg1)->rend();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::BerdyDynamicVariable >::reverse_iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_clear(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_clear",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_clear" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  (arg1)->clear();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_get_allocator(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< std::allocator< iDynTree::BerdyDynamicVariable > > result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_get_allocator",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_get_allocator" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  result = ((std::vector< iDynTree::BerdyDynamicVariable > const *)arg1)->get_allocator();
  _out = SWIG_NewPointerObj((new std::vector< iDynTree::BerdyDynamicVariable >::allocator_type(static_cast< const std::vector< iDynTree::BerdyDynamicVariable >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_iDynTree__BerdyDynamicVariable_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_BerdyDynamicVariables__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable > *result = 0 ;
  
  if (!SWIG_check_num_args("new_BerdyDynamicVariables",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BerdyDynamicVariables" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::size_type""'");
  } 
  arg1 = static_cast< std::vector< iDynTree::BerdyDynamicVariable >::size_type >(val1);
  result = (std::vector< iDynTree::BerdyDynamicVariable > *)new std::vector< iDynTree::BerdyDynamicVariable >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_pop_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_pop_back",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_pop_back" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  (arg1)->pop_back();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  std::vector< iDynTree::BerdyDynamicVariable >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_resize" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyDynamicVariables_resize" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::BerdyDynamicVariable >::size_type >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_erase__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  std::vector< iDynTree::BerdyDynamicVariable >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable >::iterator result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_erase",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_erase" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdyDynamicVariables_erase" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdyDynamicVariables_erase" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::iterator""'");
    }
  }
  result = std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__erase__SWIG_0(arg1,arg2);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::BerdyDynamicVariable >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_erase__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  std::vector< iDynTree::BerdyDynamicVariable >::iterator arg2 ;
  std::vector< iDynTree::BerdyDynamicVariable >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  swig::MatlabSwigIterator *iter3 = 0 ;
  int res3 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable >::iterator result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_erase",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_erase" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdyDynamicVariables_erase" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdyDynamicVariables_erase" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter3), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdyDynamicVariables_erase" "', argument " "3"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdyDynamicVariables_erase" "', argument " "3"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::iterator""'");
    }
  }
  result = std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__erase__SWIG_1(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::BerdyDynamicVariable >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_erase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::BerdyDynamicVariable,std::allocator< iDynTree::BerdyDynamicVariable > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_BerdyDynamicVariables_erase__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::BerdyDynamicVariable,std::allocator< iDynTree::BerdyDynamicVariable > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *>(iter) != 0));
      if (_v) {
        swig::MatlabSwigIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_BerdyDynamicVariables_erase__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdyDynamicVariables_erase'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::BerdyDynamicVariable >::erase(std::vector< iDynTree::BerdyDynamicVariable >::iterator)\n"
    "    std::vector< iDynTree::BerdyDynamicVariable >::erase(std::vector< iDynTree::BerdyDynamicVariable >::iterator,std::vector< iDynTree::BerdyDynamicVariable >::iterator)\n");
  return 1;
}


int _wrap_new_BerdyDynamicVariables__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable >::size_type arg1 ;
  std::vector< iDynTree::BerdyDynamicVariable >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable > *result = 0 ;
  
  if (!SWIG_check_num_args("new_BerdyDynamicVariables",argc,2,2,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BerdyDynamicVariables" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::size_type""'");
  } 
  arg1 = static_cast< std::vector< iDynTree::BerdyDynamicVariable >::size_type >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__BerdyDynamicVariable,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BerdyDynamicVariables" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BerdyDynamicVariables" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable >::value_type * >(argp2);
  result = (std::vector< iDynTree::BerdyDynamicVariable > *)new std::vector< iDynTree::BerdyDynamicVariable >(arg1,(std::vector< iDynTree::BerdyDynamicVariable >::value_type const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_BerdyDynamicVariables(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_BerdyDynamicVariables__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_BerdyDynamicVariables__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::BerdyDynamicVariable,std::allocator< iDynTree::BerdyDynamicVariable > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BerdyDynamicVariables__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_BerdyDynamicVariables__SWIG_3(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_BerdyDynamicVariables'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::BerdyDynamicVariable >::vector()\n"
    "    std::vector< iDynTree::BerdyDynamicVariable >::vector(std::vector< iDynTree::BerdyDynamicVariable > const &)\n"
    "    std::vector< iDynTree::BerdyDynamicVariable >::vector(std::vector< iDynTree::BerdyDynamicVariable >::size_type)\n"
    "    std::vector< iDynTree::BerdyDynamicVariable >::vector(std::vector< iDynTree::BerdyDynamicVariable >::size_type,std::vector< iDynTree::BerdyDynamicVariable >::value_type const &)\n");
  return 1;
}


int _wrap_BerdyDynamicVariables_push_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  std::vector< iDynTree::BerdyDynamicVariable >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_push_back",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_push_back" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__BerdyDynamicVariable,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyDynamicVariables_push_back" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyDynamicVariables_push_back" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable >::value_type * >(argp2);
  (arg1)->push_back((std::vector< iDynTree::BerdyDynamicVariable >::value_type const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_front(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable >::value_type *result = 0 ;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_front",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_front" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  result = (std::vector< iDynTree::BerdyDynamicVariable >::value_type *) &((std::vector< iDynTree::BerdyDynamicVariable > const *)arg1)->front();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable >::value_type *result = 0 ;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_back",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_back" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  result = (std::vector< iDynTree::BerdyDynamicVariable >::value_type *) &((std::vector< iDynTree::BerdyDynamicVariable > const *)arg1)->back();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_assign(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  std::vector< iDynTree::BerdyDynamicVariable >::size_type arg2 ;
  std::vector< iDynTree::BerdyDynamicVariable >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_assign",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_assign" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyDynamicVariables_assign" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::BerdyDynamicVariable >::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__BerdyDynamicVariable,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyDynamicVariables_assign" "', argument " "3"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyDynamicVariables_assign" "', argument " "3"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable >::value_type * >(argp3);
  (arg1)->assign(arg2,(std::vector< iDynTree::BerdyDynamicVariable >::value_type const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  std::vector< iDynTree::BerdyDynamicVariable >::size_type arg2 ;
  std::vector< iDynTree::BerdyDynamicVariable >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_resize",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_resize" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyDynamicVariables_resize" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::BerdyDynamicVariable >::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__BerdyDynamicVariable,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyDynamicVariables_resize" "', argument " "3"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyDynamicVariables_resize" "', argument " "3"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable >::value_type * >(argp3);
  (arg1)->resize(arg2,(std::vector< iDynTree::BerdyDynamicVariable >::value_type const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::BerdyDynamicVariable,std::allocator< iDynTree::BerdyDynamicVariable > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BerdyDynamicVariables_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::BerdyDynamicVariable,std::allocator< iDynTree::BerdyDynamicVariable > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BerdyDynamicVariables_resize__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdyDynamicVariables_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::BerdyDynamicVariable >::resize(std::vector< iDynTree::BerdyDynamicVariable >::size_type)\n"
    "    std::vector< iDynTree::BerdyDynamicVariable >::resize(std::vector< iDynTree::BerdyDynamicVariable >::size_type,std::vector< iDynTree::BerdyDynamicVariable >::value_type const &)\n");
  return 1;
}


int _wrap_BerdyDynamicVariables_insert__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  std::vector< iDynTree::BerdyDynamicVariable >::iterator arg2 ;
  std::vector< iDynTree::BerdyDynamicVariable >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable >::iterator result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_insert",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_insert" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdyDynamicVariables_insert" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdyDynamicVariables_insert" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__BerdyDynamicVariable,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyDynamicVariables_insert" "', argument " "3"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyDynamicVariables_insert" "', argument " "3"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable >::value_type * >(argp3);
  result = std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__insert__SWIG_0(arg1,arg2,(iDynTree::BerdyDynamicVariable const &)*arg3);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::BerdyDynamicVariable >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_insert__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  std::vector< iDynTree::BerdyDynamicVariable >::iterator arg2 ;
  std::vector< iDynTree::BerdyDynamicVariable >::size_type arg3 ;
  std::vector< iDynTree::BerdyDynamicVariable >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_insert",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_insert" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdyDynamicVariables_insert" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "BerdyDynamicVariables_insert" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BerdyDynamicVariables_insert" "', argument " "3"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::size_type""'");
  } 
  arg3 = static_cast< std::vector< iDynTree::BerdyDynamicVariable >::size_type >(val3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__BerdyDynamicVariable,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BerdyDynamicVariables_insert" "', argument " "4"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyDynamicVariables_insert" "', argument " "4"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable >::value_type * >(argp4);
  std_vector_Sl_iDynTree_BerdyDynamicVariable_Sg__insert__SWIG_1(arg1,arg2,arg3,(iDynTree::BerdyDynamicVariable const &)*arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_insert(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::BerdyDynamicVariable,std::allocator< iDynTree::BerdyDynamicVariable > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *>(iter) != 0));
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BerdyDynamicVariables_insert__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::BerdyDynamicVariable,std::allocator< iDynTree::BerdyDynamicVariable > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::BerdyDynamicVariable >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_BerdyDynamicVariables_insert__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdyDynamicVariables_insert'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::BerdyDynamicVariable >::insert(std::vector< iDynTree::BerdyDynamicVariable >::iterator,std::vector< iDynTree::BerdyDynamicVariable >::value_type const &)\n"
    "    std::vector< iDynTree::BerdyDynamicVariable >::insert(std::vector< iDynTree::BerdyDynamicVariable >::iterator,std::vector< iDynTree::BerdyDynamicVariable >::size_type,std::vector< iDynTree::BerdyDynamicVariable >::value_type const &)\n");
  return 1;
}


int _wrap_BerdyDynamicVariables_reserve(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  std::vector< iDynTree::BerdyDynamicVariable >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_reserve",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_reserve" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyDynamicVariables_reserve" "', argument " "2"" of type '" "std::vector< iDynTree::BerdyDynamicVariable >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::BerdyDynamicVariable >::size_type >(val2);
  (arg1)->reserve(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariables_capacity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable >::size_type result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariables_capacity",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariables_capacity" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  result = ((std::vector< iDynTree::BerdyDynamicVariable > const *)arg1)->capacity();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_BerdyDynamicVariables(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::BerdyDynamicVariable > *arg1 = (std::vector< iDynTree::BerdyDynamicVariable > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_BerdyDynamicVariables",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BerdyDynamicVariables" "', argument " "1"" of type '" "std::vector< iDynTree::BerdyDynamicVariable > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::BerdyDynamicVariable > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_reportInfo(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("reportInfo",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reportInfo" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "reportInfo" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "reportInfo" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  iDynTree::reportInfo((char const *)arg1,(char const *)arg2,(char const *)arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return 0;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return 1;
}


int _wrap_reportDebug(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("reportDebug",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reportDebug" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "reportDebug" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "reportDebug" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  iDynTree::reportDebug((char const *)arg1,(char const *)arg2,(char const *)arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return 0;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return 1;
}


int _wrap_IndexRange_offset_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IndexRange *arg1 = (iDynTree::IndexRange *) 0 ;
  std::ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IndexRange_offset_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IndexRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexRange_offset_set" "', argument " "1"" of type '" "iDynTree::IndexRange *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IndexRange * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndexRange_offset_set" "', argument " "2"" of type '" "std::ptrdiff_t""'");
  } 
  arg2 = static_cast< std::ptrdiff_t >(val2);
  if (arg1) (arg1)->offset = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IndexRange_offset_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IndexRange *arg1 = (iDynTree::IndexRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::ptrdiff_t result;
  
  if (!SWIG_check_num_args("IndexRange_offset_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IndexRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexRange_offset_get" "', argument " "1"" of type '" "iDynTree::IndexRange *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IndexRange * >(argp1);
  result =  ((arg1)->offset);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IndexRange_size_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IndexRange *arg1 = (iDynTree::IndexRange *) 0 ;
  std::ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IndexRange_size_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IndexRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexRange_size_set" "', argument " "1"" of type '" "iDynTree::IndexRange *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IndexRange * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndexRange_size_set" "', argument " "2"" of type '" "std::ptrdiff_t""'");
  } 
  arg2 = static_cast< std::ptrdiff_t >(val2);
  if (arg1) (arg1)->size = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IndexRange_size_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IndexRange *arg1 = (iDynTree::IndexRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::ptrdiff_t result;
  
  if (!SWIG_check_num_args("IndexRange_size_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IndexRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexRange_size_get" "', argument " "1"" of type '" "iDynTree::IndexRange *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IndexRange * >(argp1);
  result =  ((arg1)->size);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IndexRange_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IndexRange *arg1 = (iDynTree::IndexRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IndexRange_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IndexRange, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndexRange_isValid" "', argument " "1"" of type '" "iDynTree::IndexRange const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IndexRange * >(argp1);
  result = (bool)((iDynTree::IndexRange const *)arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IndexRange_InvalidRange(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::IndexRange result;
  
  if (!SWIG_check_num_args("IndexRange_InvalidRange",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = iDynTree::IndexRange::InvalidRange();
  _out = SWIG_NewPointerObj((new iDynTree::IndexRange(static_cast< const iDynTree::IndexRange& >(result))), SWIGTYPE_p_iDynTree__IndexRange, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_IndexRange(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::IndexRange *result = 0 ;
  
  if (!SWIG_check_num_args("new_IndexRange",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::IndexRange *)new iDynTree::IndexRange();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IndexRange, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_IndexRange(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IndexRange *arg1 = (iDynTree::IndexRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_IndexRange",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IndexRange, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IndexRange" "', argument " "1"" of type '" "iDynTree::IndexRange *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IndexRange * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_checkDoublesAreEqual__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double arg3 ;
  double temp1 ;
  double val1 ;
  int ecode1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("checkDoublesAreEqual",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "checkDoublesAreEqual" "', argument " "1"" of type '" "double""'");
  } 
  temp1 = static_cast< double >(val1);
  arg1 = &temp1;
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "checkDoublesAreEqual" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "checkDoublesAreEqual" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)iDynTree::checkDoublesAreEqual((double const &)*arg1,(double const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_checkDoublesAreEqual__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = 0 ;
  double *arg2 = 0 ;
  double temp1 ;
  double val1 ;
  int ecode1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("checkDoublesAreEqual",argc,2,2,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "checkDoublesAreEqual" "', argument " "1"" of type '" "double""'");
  } 
  temp1 = static_cast< double >(val1);
  arg1 = &temp1;
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "checkDoublesAreEqual" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  result = (bool)iDynTree::checkDoublesAreEqual((double const &)*arg1,(double const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_checkDoublesAreEqual(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_checkDoublesAreEqual__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_checkDoublesAreEqual__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'checkDoublesAreEqual'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::checkDoublesAreEqual(double const &,double const &,double)\n"
    "    iDynTree::checkDoublesAreEqual(double const &,double const &)\n");
  return 1;
}


int _wrap_new_MatrixDynSize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::MatrixDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("new_MatrixDynSize",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::MatrixDynSize *)new iDynTree::MatrixDynSize();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixDynSize, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_MatrixDynSize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  std::size_t arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::MatrixDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("new_MatrixDynSize",argc,2,2,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MatrixDynSize" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MatrixDynSize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (iDynTree::MatrixDynSize *)new iDynTree::MatrixDynSize(arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixDynSize, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_MatrixDynSize__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::MatrixDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("new_MatrixDynSize",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixDynSize" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MatrixDynSize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MatrixDynSize" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (iDynTree::MatrixDynSize *)new iDynTree::MatrixDynSize((double const *)arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixDynSize, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_MatrixDynSize__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("new_MatrixDynSize",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixDynSize" "', argument " "1"" of type '" "iDynTree::MatrixDynSize const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixDynSize" "', argument " "1"" of type '" "iDynTree::MatrixDynSize const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  result = (iDynTree::MatrixDynSize *)new iDynTree::MatrixDynSize((iDynTree::MatrixDynSize const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixDynSize, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_MatrixDynSize__SWIG_4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::MatrixView< double const > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("new_MatrixDynSize",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixDynSize" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixDynSize" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::MatrixView< double const > * >(argp1));
    }
  }
  result = (iDynTree::MatrixDynSize *)new iDynTree::MatrixDynSize(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixDynSize, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_MatrixDynSize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_MatrixDynSize__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MatrixDynSize__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MatrixDynSize__SWIG_4(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MatrixDynSize__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MatrixDynSize__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_MatrixDynSize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixDynSize::MatrixDynSize()\n"
    "    iDynTree::MatrixDynSize::MatrixDynSize(std::size_t,std::size_t)\n"
    "    iDynTree::MatrixDynSize::MatrixDynSize(double const *,std::size_t const,std::size_t const)\n"
    "    iDynTree::MatrixDynSize::MatrixDynSize(iDynTree::MatrixDynSize const &)\n"
    "    iDynTree::MatrixDynSize::MatrixDynSize(iDynTree::MatrixView< double const >)\n");
  return 1;
}


int _wrap_delete_MatrixDynSize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_MatrixDynSize",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MatrixDynSize" "', argument " "1"" of type '" "iDynTree::MatrixDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("MatrixDynSize_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_paren" "', argument " "1"" of type '" "iDynTree::MatrixDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatrixDynSize_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MatrixDynSize_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixDynSize const *)arg1)->operator ()(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("MatrixDynSize_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_paren" "', argument " "1"" of type '" "iDynTree::MatrixDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatrixDynSize_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MatrixDynSize_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double *) &(arg1)->operator ()(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MatrixDynSize_paren__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MatrixDynSize_paren__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'MatrixDynSize_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixDynSize::operator ()(std::size_t const,std::size_t const) const\n"
    "    iDynTree::MatrixDynSize::operator ()(std::size_t const,std::size_t const)\n");
  return 1;
}


int _wrap_MatrixDynSize_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("MatrixDynSize_getVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_getVal" "', argument " "1"" of type '" "iDynTree::MatrixDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatrixDynSize_getVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MatrixDynSize_getVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixDynSize const *)arg1)->getVal(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("MatrixDynSize_setVal",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_setVal" "', argument " "1"" of type '" "iDynTree::MatrixDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatrixDynSize_setVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MatrixDynSize_setVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MatrixDynSize_setVal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->setVal(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_rows(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("MatrixDynSize_rows",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_rows" "', argument " "1"" of type '" "iDynTree::MatrixDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  result = ((iDynTree::MatrixDynSize const *)arg1)->rows();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_cols(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("MatrixDynSize_cols",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_cols" "', argument " "1"" of type '" "iDynTree::MatrixDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  result = ((iDynTree::MatrixDynSize const *)arg1)->cols();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_data(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("MatrixDynSize_data",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_data" "', argument " "1"" of type '" "iDynTree::MatrixDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  result = (double *)(arg1)->data();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MatrixDynSize_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_zero" "', argument " "1"" of type '" "iDynTree::MatrixDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MatrixDynSize_resize",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_resize" "', argument " "1"" of type '" "iDynTree::MatrixDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatrixDynSize_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MatrixDynSize_resize" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  (arg1)->resize(arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_reserve(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MatrixDynSize_reserve",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_reserve" "', argument " "1"" of type '" "iDynTree::MatrixDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatrixDynSize_reserve" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->reserve(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_capacity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("MatrixDynSize_capacity",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_capacity" "', argument " "1"" of type '" "iDynTree::MatrixDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  result = ((iDynTree::MatrixDynSize const *)arg1)->capacity();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_shrink_to_fit(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MatrixDynSize_shrink_to_fit",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_shrink_to_fit" "', argument " "1"" of type '" "iDynTree::MatrixDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  (arg1)->shrink_to_fit();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_fillRowMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MatrixDynSize_fillRowMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_fillRowMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixDynSize_fillRowMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixDynSize const *)arg1)->fillRowMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_fillColMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MatrixDynSize_fillColMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_fillColMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixDynSize_fillColMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixDynSize const *)arg1)->fillColMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("MatrixDynSize_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_toString" "', argument " "1"" of type '" "iDynTree::MatrixDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  result = ((iDynTree::MatrixDynSize const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("MatrixDynSize_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_display" "', argument " "1"" of type '" "iDynTree::MatrixDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  result = ((iDynTree::MatrixDynSize const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("MatrixDynSize_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_toMatlab" "', argument " "1"" of type '" "iDynTree::MatrixDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  result = (mxArray *)iDynTree_MatrixDynSize_toMatlab((iDynTree::MatrixDynSize const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MatrixDynSize_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixDynSize *arg1 = (iDynTree::MatrixDynSize *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MatrixDynSize_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixDynSize_fromMatlab" "', argument " "1"" of type '" "iDynTree::MatrixDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp1);
  arg2 = argv[1];
  iDynTree_MatrixDynSize_fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SparseMatrixRowMajor__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SparseMatrix< iDynTree::RowMajor > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SparseMatrixRowMajor",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::SparseMatrix< iDynTree::RowMajor > *)new iDynTree::SparseMatrix< iDynTree::RowMajor >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SparseMatrixRowMajor__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  std::size_t arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SparseMatrix< iDynTree::RowMajor > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SparseMatrixRowMajor",argc,2,2,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SparseMatrixRowMajor" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SparseMatrixRowMajor" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (iDynTree::SparseMatrix< iDynTree::RowMajor > *)new iDynTree::SparseMatrix< iDynTree::RowMajor >(arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SparseMatrixRowMajor__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  std::size_t arg2 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::SparseMatrix< iDynTree::RowMajor > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SparseMatrixRowMajor",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SparseMatrixRowMajor" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SparseMatrixRowMajor" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SparseMatrixRowMajor" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SparseMatrixRowMajor" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  result = (iDynTree::SparseMatrix< iDynTree::RowMajor > *)new iDynTree::SparseMatrix< iDynTree::RowMajor >(arg1,arg2,(iDynTree::VectorDynSize const &)*arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SparseMatrixRowMajor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_SparseMatrixRowMajor__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SparseMatrixRowMajor__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SparseMatrixRowMajor__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_SparseMatrixRowMajor'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SparseMatrix< iDynTree::RowMajor >::SparseMatrix()\n"
    "    iDynTree::SparseMatrix< iDynTree::RowMajor >::SparseMatrix(std::size_t,std::size_t)\n"
    "    iDynTree::SparseMatrix< iDynTree::RowMajor >::SparseMatrix(std::size_t,std::size_t,iDynTree::VectorDynSize const &)\n");
  return 1;
}


int _wrap_delete_SparseMatrixRowMajor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SparseMatrixRowMajor",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SparseMatrixRowMajor" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_numberOfNonZeros(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_numberOfNonZeros",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_numberOfNonZeros" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  result = ((iDynTree::SparseMatrix< iDynTree::RowMajor > const *)arg1)->numberOfNonZeros();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_resize",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_resize" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixRowMajor_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrixRowMajor_resize" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  (arg1)->resize(arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_resize",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_resize" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixRowMajor_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrixRowMajor_resize" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrixRowMajor_resize" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrixRowMajor_resize" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  (arg1)->resize(arg2,arg3,(iDynTree::VectorDynSize const &)*arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SparseMatrixRowMajor_resize__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SparseMatrixRowMajor_resize__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SparseMatrixRowMajor_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SparseMatrix< iDynTree::RowMajor >::resize(std::size_t,std::size_t)\n"
    "    iDynTree::SparseMatrix< iDynTree::RowMajor >::resize(std::size_t,std::size_t,iDynTree::VectorDynSize const &)\n");
  return 1;
}


int _wrap_SparseMatrixRowMajor_reserve(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_reserve",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_reserve" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixRowMajor_reserve" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->reserve(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_zero" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_setFromConstTriplets(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  iDynTree::Triplets *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_setFromConstTriplets",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_setFromConstTriplets" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Triplets,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrixRowMajor_setFromConstTriplets" "', argument " "2"" of type '" "iDynTree::Triplets const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrixRowMajor_setFromConstTriplets" "', argument " "2"" of type '" "iDynTree::Triplets const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Triplets * >(argp2);
  (arg1)->setFromConstTriplets((iDynTree::Triplets const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_setFromTriplets(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  iDynTree::Triplets *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_setFromTriplets",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_setFromTriplets" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Triplets,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrixRowMajor_setFromTriplets" "', argument " "2"" of type '" "iDynTree::Triplets &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrixRowMajor_setFromTriplets" "', argument " "2"" of type '" "iDynTree::Triplets &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Triplets * >(argp2);
  (arg1)->setFromTriplets(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_sparseMatrixFromTriplets(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  std::size_t arg2 ;
  iDynTree::Triplets *arg3 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::SparseMatrix< iDynTree::RowMajor > result;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_sparseMatrixFromTriplets",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SparseMatrixRowMajor_sparseMatrixFromTriplets" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixRowMajor_sparseMatrixFromTriplets" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Triplets,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrixRowMajor_sparseMatrixFromTriplets" "', argument " "3"" of type '" "iDynTree::Triplets const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrixRowMajor_sparseMatrixFromTriplets" "', argument " "3"" of type '" "iDynTree::Triplets const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Triplets * >(argp3);
  result = iDynTree::SparseMatrix< iDynTree::RowMajor >::SWIGTEMPLATEDISAMBIGUATOR sparseMatrixFromTriplets(arg1,arg2,(iDynTree::Triplets const &)*arg3);
  _out = SWIG_NewPointerObj((new iDynTree::SparseMatrix< iDynTree::RowMajor >(static_cast< const iDynTree::SparseMatrix< iDynTree::RowMajor >& >(result))), SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_paren" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixRowMajor_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrixRowMajor_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::SparseMatrix< iDynTree::RowMajor > const *)arg1)->operator ()(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_paren" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixRowMajor_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrixRowMajor_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double *) &(arg1)->operator ()(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SparseMatrixRowMajor_paren__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SparseMatrixRowMajor_paren__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SparseMatrixRowMajor_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SparseMatrix< iDynTree::RowMajor >::operator ()(std::size_t,std::size_t) const\n"
    "    iDynTree::SparseMatrix< iDynTree::RowMajor >::operator ()(std::size_t,std::size_t)\n");
  return 1;
}


int _wrap_SparseMatrixRowMajor_getValue(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_getValue",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_getValue" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixRowMajor_getValue" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrixRowMajor_getValue" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::SparseMatrix< iDynTree::RowMajor > const *)arg1)->getValue(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_setValue(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_setValue",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_setValue" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixRowMajor_setValue" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrixRowMajor_setValue" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrixRowMajor_setValue" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_rows(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_rows",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_rows" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  result = ((iDynTree::SparseMatrix< iDynTree::RowMajor > const *)arg1)->rows();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_columns(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_columns",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_columns" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  result = ((iDynTree::SparseMatrix< iDynTree::RowMajor > const *)arg1)->columns();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_description__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_description",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_description" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixRowMajor_description" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = ((iDynTree::SparseMatrix< iDynTree::RowMajor > const *)arg1)->description(arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_description__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_description",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_description" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  result = ((iDynTree::SparseMatrix< iDynTree::RowMajor > const *)arg1)->description();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_description(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SparseMatrixRowMajor_description__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SparseMatrixRowMajor_description__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SparseMatrixRowMajor_description'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SparseMatrix< iDynTree::RowMajor >::description(bool) const\n"
    "    iDynTree::SparseMatrix< iDynTree::RowMajor >::description() const\n");
  return 1;
}


int _wrap_SparseMatrixRowMajor_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_toMatlab" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  result = (mxArray *)iDynTree_SparseMatrix_Sl_iDynTree_RowMajor_Sg__toMatlab((iDynTree::SparseMatrix< iDynTree::RowMajor > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_toMatlabDense(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_toMatlabDense",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_toMatlabDense" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  result = (mxArray *)iDynTree_SparseMatrix_Sl_iDynTree_RowMajor_Sg__toMatlabDense((iDynTree::SparseMatrix< iDynTree::RowMajor > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixRowMajor_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::RowMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::RowMajor > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixRowMajor_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixRowMajor_fromMatlab" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::RowMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::RowMajor > * >(argp1);
  arg2 = argv[1];
  iDynTree_SparseMatrix_Sl_iDynTree_RowMajor_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SparseMatrixColMajor__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SparseMatrixColMajor",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *)new iDynTree::SparseMatrix< iDynTree::ColumnMajor >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SparseMatrixColMajor__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  std::size_t arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SparseMatrixColMajor",argc,2,2,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SparseMatrixColMajor" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SparseMatrixColMajor" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *)new iDynTree::SparseMatrix< iDynTree::ColumnMajor >(arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SparseMatrixColMajor__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  std::size_t arg2 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SparseMatrixColMajor",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SparseMatrixColMajor" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SparseMatrixColMajor" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SparseMatrixColMajor" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SparseMatrixColMajor" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  result = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *)new iDynTree::SparseMatrix< iDynTree::ColumnMajor >(arg1,arg2,(iDynTree::VectorDynSize const &)*arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SparseMatrixColMajor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_SparseMatrixColMajor__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_SparseMatrixColMajor__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SparseMatrixColMajor__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_SparseMatrixColMajor'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SparseMatrix< iDynTree::ColumnMajor >::SparseMatrix()\n"
    "    iDynTree::SparseMatrix< iDynTree::ColumnMajor >::SparseMatrix(std::size_t,std::size_t)\n"
    "    iDynTree::SparseMatrix< iDynTree::ColumnMajor >::SparseMatrix(std::size_t,std::size_t,iDynTree::VectorDynSize const &)\n");
  return 1;
}


int _wrap_delete_SparseMatrixColMajor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SparseMatrixColMajor",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SparseMatrixColMajor" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_numberOfNonZeros(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_numberOfNonZeros",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_numberOfNonZeros" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  result = ((iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *)arg1)->numberOfNonZeros();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_resize",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_resize" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixColMajor_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrixColMajor_resize" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  (arg1)->resize(arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_resize",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_resize" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixColMajor_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrixColMajor_resize" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrixColMajor_resize" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrixColMajor_resize" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  (arg1)->resize(arg2,arg3,(iDynTree::VectorDynSize const &)*arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SparseMatrixColMajor_resize__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SparseMatrixColMajor_resize__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SparseMatrixColMajor_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SparseMatrix< iDynTree::ColumnMajor >::resize(std::size_t,std::size_t)\n"
    "    iDynTree::SparseMatrix< iDynTree::ColumnMajor >::resize(std::size_t,std::size_t,iDynTree::VectorDynSize const &)\n");
  return 1;
}


int _wrap_SparseMatrixColMajor_reserve(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_reserve",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_reserve" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixColMajor_reserve" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->reserve(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_zero" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_setFromConstTriplets(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  iDynTree::Triplets *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_setFromConstTriplets",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_setFromConstTriplets" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Triplets,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrixColMajor_setFromConstTriplets" "', argument " "2"" of type '" "iDynTree::Triplets const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrixColMajor_setFromConstTriplets" "', argument " "2"" of type '" "iDynTree::Triplets const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Triplets * >(argp2);
  (arg1)->setFromConstTriplets((iDynTree::Triplets const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_setFromTriplets(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  iDynTree::Triplets *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_setFromTriplets",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_setFromTriplets" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Triplets,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrixColMajor_setFromTriplets" "', argument " "2"" of type '" "iDynTree::Triplets &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrixColMajor_setFromTriplets" "', argument " "2"" of type '" "iDynTree::Triplets &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Triplets * >(argp2);
  (arg1)->setFromTriplets(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_sparseMatrixFromTriplets(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  std::size_t arg2 ;
  iDynTree::Triplets *arg3 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > result;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_sparseMatrixFromTriplets",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "SparseMatrixColMajor_sparseMatrixFromTriplets" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixColMajor_sparseMatrixFromTriplets" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Triplets,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrixColMajor_sparseMatrixFromTriplets" "', argument " "3"" of type '" "iDynTree::Triplets const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrixColMajor_sparseMatrixFromTriplets" "', argument " "3"" of type '" "iDynTree::Triplets const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Triplets * >(argp3);
  result = iDynTree::SparseMatrix< iDynTree::ColumnMajor >::SWIGTEMPLATEDISAMBIGUATOR sparseMatrixFromTriplets(arg1,arg2,(iDynTree::Triplets const &)*arg3);
  _out = SWIG_NewPointerObj((new iDynTree::SparseMatrix< iDynTree::ColumnMajor >(static_cast< const iDynTree::SparseMatrix< iDynTree::ColumnMajor >& >(result))), SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_paren" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixColMajor_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrixColMajor_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *)arg1)->operator ()(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_paren" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixColMajor_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrixColMajor_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double *) &(arg1)->operator ()(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SparseMatrixColMajor_paren__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SparseMatrixColMajor_paren__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SparseMatrixColMajor_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SparseMatrix< iDynTree::ColumnMajor >::operator ()(std::size_t,std::size_t) const\n"
    "    iDynTree::SparseMatrix< iDynTree::ColumnMajor >::operator ()(std::size_t,std::size_t)\n");
  return 1;
}


int _wrap_SparseMatrixColMajor_getValue(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_getValue",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_getValue" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixColMajor_getValue" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrixColMajor_getValue" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *)arg1)->getValue(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_setValue(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_setValue",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_setValue" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixColMajor_setValue" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrixColMajor_setValue" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrixColMajor_setValue" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  (arg1)->setValue(arg2,arg3,arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_rows(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_rows",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_rows" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  result = ((iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *)arg1)->rows();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_columns(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_columns",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_columns" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  result = ((iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *)arg1)->columns();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_description__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_description",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_description" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrixColMajor_description" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = ((iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *)arg1)->description(arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_description__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_description",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_description" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  result = ((iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *)arg1)->description();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_description(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SparseMatrixColMajor_description__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SparseMatrixColMajor_description__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SparseMatrixColMajor_description'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SparseMatrix< iDynTree::ColumnMajor >::description(bool) const\n"
    "    iDynTree::SparseMatrix< iDynTree::ColumnMajor >::description() const\n");
  return 1;
}


int _wrap_SparseMatrixColMajor_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_toMatlab" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  result = (mxArray *)iDynTree_SparseMatrix_Sl_iDynTree_ColumnMajor_Sg__toMatlab((iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_toMatlabDense(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_toMatlabDense",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_toMatlabDense" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  result = (mxArray *)iDynTree_SparseMatrix_Sl_iDynTree_ColumnMajor_Sg__toMatlabDense((iDynTree::SparseMatrix< iDynTree::ColumnMajor > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SparseMatrixColMajor_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg1 = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SparseMatrixColMajor_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixColMajor_fromMatlab" "', argument " "1"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp1);
  arg2 = argv[1];
  iDynTree_SparseMatrix_Sl_iDynTree_ColumnMajor_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_VectorDynSize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::VectorDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("new_VectorDynSize",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::VectorDynSize *)new iDynTree::VectorDynSize();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorDynSize, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_VectorDynSize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::VectorDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("new_VectorDynSize",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_VectorDynSize" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  result = (iDynTree::VectorDynSize *)new iDynTree::VectorDynSize(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorDynSize, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_VectorDynSize__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::VectorDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("new_VectorDynSize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDynSize" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorDynSize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (iDynTree::VectorDynSize *)new iDynTree::VectorDynSize((double const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorDynSize, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_VectorDynSize__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::VectorDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("new_VectorDynSize",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDynSize" "', argument " "1"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorDynSize" "', argument " "1"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  result = (iDynTree::VectorDynSize *)new iDynTree::VectorDynSize((iDynTree::VectorDynSize const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorDynSize, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_VectorDynSize__SWIG_4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::VectorDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("new_VectorDynSize",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDynSize" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorDynSize" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp1));
    }
  }
  result = (iDynTree::VectorDynSize *)new iDynTree::VectorDynSize(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorDynSize, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_VectorDynSize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_VectorDynSize__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorDynSize__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VectorDynSize__SWIG_4(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VectorDynSize__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_VectorDynSize__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_VectorDynSize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorDynSize::VectorDynSize()\n"
    "    iDynTree::VectorDynSize::VectorDynSize(std::size_t)\n"
    "    iDynTree::VectorDynSize::VectorDynSize(double const *,std::size_t const)\n"
    "    iDynTree::VectorDynSize::VectorDynSize(iDynTree::VectorDynSize const &)\n"
    "    iDynTree::VectorDynSize::VectorDynSize(iDynTree::Span< double const,-1 >)\n");
  return 1;
}


int _wrap_delete_VectorDynSize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_VectorDynSize",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorDynSize" "', argument " "1"" of type '" "iDynTree::VectorDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("VectorDynSize_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_paren" "', argument " "1"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDynSize_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorDynSize const *)arg1)->operator ()(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("VectorDynSize_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_paren" "', argument " "1"" of type '" "iDynTree::VectorDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDynSize_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorDynSize_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorDynSize_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'VectorDynSize_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorDynSize::operator ()(std::size_t const) const\n"
    "    iDynTree::VectorDynSize::operator ()(std::size_t const)\n");
  return 1;
}


int _wrap_VectorDynSize_brace__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("VectorDynSize_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_brace" "', argument " "1"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDynSize_brace" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorDynSize const *)arg1)->operator [](arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_brace__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("VectorDynSize_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_brace" "', argument " "1"" of type '" "iDynTree::VectorDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDynSize_brace" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double *) &(arg1)->operator [](arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_brace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorDynSize_brace__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VectorDynSize_brace__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'VectorDynSize_brace'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorDynSize::operator [](std::size_t const) const\n"
    "    iDynTree::VectorDynSize::operator [](std::size_t const)\n");
  return 1;
}


int _wrap_VectorDynSize_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("VectorDynSize_getVal",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_getVal" "', argument " "1"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDynSize_getVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorDynSize const *)arg1)->getVal(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  std::size_t arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("VectorDynSize_setVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_setVal" "', argument " "1"" of type '" "iDynTree::VectorDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDynSize_setVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorDynSize_setVal" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->setVal(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_begin__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("VectorDynSize_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_begin" "', argument " "1"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  result = (double *)((iDynTree::VectorDynSize const *)arg1)->begin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_end__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("VectorDynSize_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_end" "', argument " "1"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  result = (double *)((iDynTree::VectorDynSize const *)arg1)->end();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_cbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("VectorDynSize_cbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_cbegin" "', argument " "1"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  result = (double *)((iDynTree::VectorDynSize const *)arg1)->cbegin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_cend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("VectorDynSize_cend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_cend" "', argument " "1"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  result = (double *)((iDynTree::VectorDynSize const *)arg1)->cend();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_begin__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("VectorDynSize_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_begin" "', argument " "1"" of type '" "iDynTree::VectorDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  result = (double *)(arg1)->begin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_begin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VectorDynSize_begin__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VectorDynSize_begin__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'VectorDynSize_begin'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorDynSize::begin() const\n"
    "    iDynTree::VectorDynSize::begin()\n");
  return 1;
}


int _wrap_VectorDynSize_end__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("VectorDynSize_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_end" "', argument " "1"" of type '" "iDynTree::VectorDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  result = (double *)(arg1)->end();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_end(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VectorDynSize_end__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VectorDynSize_end__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'VectorDynSize_end'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorDynSize::end() const\n"
    "    iDynTree::VectorDynSize::end()\n");
  return 1;
}


int _wrap_VectorDynSize_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("VectorDynSize_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_size" "', argument " "1"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  result = ((iDynTree::VectorDynSize const *)arg1)->size();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_data(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("VectorDynSize_data",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_data" "', argument " "1"" of type '" "iDynTree::VectorDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  result = (double *)(arg1)->data();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("VectorDynSize_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_zero" "', argument " "1"" of type '" "iDynTree::VectorDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_reserve(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("VectorDynSize_reserve",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_reserve" "', argument " "1"" of type '" "iDynTree::VectorDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDynSize_reserve" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->reserve(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("VectorDynSize_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_resize" "', argument " "1"" of type '" "iDynTree::VectorDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDynSize_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_shrink_to_fit(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("VectorDynSize_shrink_to_fit",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_shrink_to_fit" "', argument " "1"" of type '" "iDynTree::VectorDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  (arg1)->shrink_to_fit();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_capacity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("VectorDynSize_capacity",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_capacity" "', argument " "1"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  result = ((iDynTree::VectorDynSize const *)arg1)->capacity();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_fillBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("VectorDynSize_fillBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_fillBuffer" "', argument " "1"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDynSize_fillBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::VectorDynSize const *)arg1)->fillBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("VectorDynSize_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_toString" "', argument " "1"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  result = ((iDynTree::VectorDynSize const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("VectorDynSize_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_display" "', argument " "1"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  result = ((iDynTree::VectorDynSize const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("VectorDynSize_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_toMatlab" "', argument " "1"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  result = (mxArray *)iDynTree_VectorDynSize_toMatlab((iDynTree::VectorDynSize const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VectorDynSize_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorDynSize *arg1 = (iDynTree::VectorDynSize *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("VectorDynSize_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDynSize_fromMatlab" "', argument " "1"" of type '" "iDynTree::VectorDynSize *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorDynSize * >(argp1);
  arg2 = argv[1];
  iDynTree_VectorDynSize_fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix1x6__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::MatrixFixSize< 1,6 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix1x6",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::MatrixFixSize< 1,6 > *)new iDynTree::MatrixFixSize< 1,6 >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix1x6__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::MatrixFixSize< 1,6 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix1x6",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix1x6" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Matrix1x6" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Matrix1x6" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (iDynTree::MatrixFixSize< 1,6 > *)new iDynTree::MatrixFixSize< 1,6 >((double const *)arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix1x6__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::MatrixView< double const > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixFixSize< 1,6 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix1x6",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix1x6" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Matrix1x6" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::MatrixView< double const > * >(argp1));
    }
  }
  result = (iDynTree::MatrixFixSize< 1,6 > *)new iDynTree::MatrixFixSize< 1,6 >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix1x6(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Matrix1x6__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Matrix1x6__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Matrix1x6__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Matrix1x6'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixFixSize< 1,6 >::MatrixFixSize()\n"
    "    iDynTree::MatrixFixSize< 1,6 >::MatrixFixSize(double const *,std::size_t const,std::size_t const)\n"
    "    iDynTree::MatrixFixSize< 1,6 >::MatrixFixSize(iDynTree::MatrixView< double const >)\n");
  return 1;
}


int _wrap_Matrix1x6_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Matrix1x6_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix1x6_paren" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix1x6_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix1x6_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixFixSize< 1,6 > const *)arg1)->operator ()(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix1x6_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix1x6_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix1x6_paren" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix1x6_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix1x6_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double *) &(arg1)->operator ()(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix1x6_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix1x6_paren__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix1x6_paren__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Matrix1x6_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixFixSize< 1,6 >::operator ()(std::size_t const,std::size_t const) const\n"
    "    iDynTree::MatrixFixSize< 1,6 >::operator ()(std::size_t const,std::size_t const)\n");
  return 1;
}


int _wrap_Matrix1x6_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Matrix1x6_getVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix1x6_getVal" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix1x6_getVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix1x6_getVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixFixSize< 1,6 > const *)arg1)->getVal(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix1x6_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Matrix1x6_setVal",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix1x6_setVal" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix1x6_setVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix1x6_setVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Matrix1x6_setVal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->setVal(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix1x6_rows(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Matrix1x6_rows",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix1x6_rows" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 1,6 > const *)arg1)->rows();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix1x6_cols(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Matrix1x6_cols",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix1x6_cols" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 1,6 > const *)arg1)->cols();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix1x6_data(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix1x6_data",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix1x6_data" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  result = (double *)(arg1)->data();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix1x6_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix1x6_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix1x6_zero" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix1x6_fillRowMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix1x6_fillRowMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix1x6_fillRowMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix1x6_fillRowMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixFixSize< 1,6 > const *)arg1)->fillRowMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix1x6_fillColMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix1x6_fillColMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix1x6_fillColMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix1x6_fillColMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixFixSize< 1,6 > const *)arg1)->fillColMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix1x6_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Matrix1x6_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix1x6_toString" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 1,6 > const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix1x6_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Matrix1x6_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix1x6_display" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 1,6 > const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix1x6_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix1x6_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix1x6_toMatlab" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  result = (mxArray *)iDynTree_MatrixFixSize_Sl_1_Sc_6_Sg__toMatlab((iDynTree::MatrixFixSize< 1,6 > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix1x6_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix1x6_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix1x6_fromMatlab" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  arg2 = argv[1];
  iDynTree_MatrixFixSize_Sl_1_Sc_6_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Matrix1x6(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 1,6 > *arg1 = (iDynTree::MatrixFixSize< 1,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Matrix1x6",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_1_6_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matrix1x6" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 1,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 1,6 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix2x3__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::MatrixFixSize< 2,3 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix2x3",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::MatrixFixSize< 2,3 > *)new iDynTree::MatrixFixSize< 2,3 >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix2x3__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::MatrixFixSize< 2,3 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix2x3",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix2x3" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Matrix2x3" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Matrix2x3" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (iDynTree::MatrixFixSize< 2,3 > *)new iDynTree::MatrixFixSize< 2,3 >((double const *)arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix2x3__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::MatrixView< double const > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixFixSize< 2,3 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix2x3",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix2x3" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Matrix2x3" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::MatrixView< double const > * >(argp1));
    }
  }
  result = (iDynTree::MatrixFixSize< 2,3 > *)new iDynTree::MatrixFixSize< 2,3 >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix2x3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Matrix2x3__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Matrix2x3__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Matrix2x3__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Matrix2x3'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixFixSize< 2,3 >::MatrixFixSize()\n"
    "    iDynTree::MatrixFixSize< 2,3 >::MatrixFixSize(double const *,std::size_t const,std::size_t const)\n"
    "    iDynTree::MatrixFixSize< 2,3 >::MatrixFixSize(iDynTree::MatrixView< double const >)\n");
  return 1;
}


int _wrap_Matrix2x3_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Matrix2x3_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix2x3_paren" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix2x3_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix2x3_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixFixSize< 2,3 > const *)arg1)->operator ()(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix2x3_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix2x3_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix2x3_paren" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix2x3_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix2x3_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double *) &(arg1)->operator ()(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix2x3_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix2x3_paren__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix2x3_paren__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Matrix2x3_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixFixSize< 2,3 >::operator ()(std::size_t const,std::size_t const) const\n"
    "    iDynTree::MatrixFixSize< 2,3 >::operator ()(std::size_t const,std::size_t const)\n");
  return 1;
}


int _wrap_Matrix2x3_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Matrix2x3_getVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix2x3_getVal" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix2x3_getVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix2x3_getVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixFixSize< 2,3 > const *)arg1)->getVal(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix2x3_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Matrix2x3_setVal",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix2x3_setVal" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix2x3_setVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix2x3_setVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Matrix2x3_setVal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->setVal(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix2x3_rows(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Matrix2x3_rows",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix2x3_rows" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 2,3 > const *)arg1)->rows();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix2x3_cols(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Matrix2x3_cols",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix2x3_cols" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 2,3 > const *)arg1)->cols();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix2x3_data(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix2x3_data",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix2x3_data" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  result = (double *)(arg1)->data();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix2x3_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix2x3_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix2x3_zero" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix2x3_fillRowMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix2x3_fillRowMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix2x3_fillRowMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix2x3_fillRowMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixFixSize< 2,3 > const *)arg1)->fillRowMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix2x3_fillColMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix2x3_fillColMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix2x3_fillColMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix2x3_fillColMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixFixSize< 2,3 > const *)arg1)->fillColMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix2x3_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Matrix2x3_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix2x3_toString" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 2,3 > const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix2x3_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Matrix2x3_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix2x3_display" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 2,3 > const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix2x3_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix2x3_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix2x3_toMatlab" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  result = (mxArray *)iDynTree_MatrixFixSize_Sl_2_Sc_3_Sg__toMatlab((iDynTree::MatrixFixSize< 2,3 > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix2x3_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix2x3_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix2x3_fromMatlab" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  arg2 = argv[1];
  iDynTree_MatrixFixSize_Sl_2_Sc_3_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Matrix2x3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 2,3 > *arg1 = (iDynTree::MatrixFixSize< 2,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Matrix2x3",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matrix2x3" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 2,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 2,3 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix3x3__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::MatrixFixSize< 3,3 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix3x3",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::MatrixFixSize< 3,3 > *)new iDynTree::MatrixFixSize< 3,3 >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix3x3__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::MatrixFixSize< 3,3 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix3x3",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix3x3" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Matrix3x3" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Matrix3x3" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (iDynTree::MatrixFixSize< 3,3 > *)new iDynTree::MatrixFixSize< 3,3 >((double const *)arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix3x3__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::MatrixView< double const > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixFixSize< 3,3 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix3x3",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix3x3" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Matrix3x3" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::MatrixView< double const > * >(argp1));
    }
  }
  result = (iDynTree::MatrixFixSize< 3,3 > *)new iDynTree::MatrixFixSize< 3,3 >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix3x3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Matrix3x3__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Matrix3x3__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Matrix3x3__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Matrix3x3'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixFixSize< 3,3 >::MatrixFixSize()\n"
    "    iDynTree::MatrixFixSize< 3,3 >::MatrixFixSize(double const *,std::size_t const,std::size_t const)\n"
    "    iDynTree::MatrixFixSize< 3,3 >::MatrixFixSize(iDynTree::MatrixView< double const >)\n");
  return 1;
}


int _wrap_Matrix3x3_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Matrix3x3_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix3x3_paren" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix3x3_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix3x3_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixFixSize< 3,3 > const *)arg1)->operator ()(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix3x3_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix3x3_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix3x3_paren" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix3x3_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix3x3_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double *) &(arg1)->operator ()(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix3x3_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix3x3_paren__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix3x3_paren__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Matrix3x3_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixFixSize< 3,3 >::operator ()(std::size_t const,std::size_t const) const\n"
    "    iDynTree::MatrixFixSize< 3,3 >::operator ()(std::size_t const,std::size_t const)\n");
  return 1;
}


int _wrap_Matrix3x3_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Matrix3x3_getVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix3x3_getVal" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix3x3_getVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix3x3_getVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixFixSize< 3,3 > const *)arg1)->getVal(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix3x3_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Matrix3x3_setVal",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix3x3_setVal" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix3x3_setVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix3x3_setVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Matrix3x3_setVal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->setVal(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix3x3_rows(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Matrix3x3_rows",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix3x3_rows" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 3,3 > const *)arg1)->rows();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix3x3_cols(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Matrix3x3_cols",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix3x3_cols" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 3,3 > const *)arg1)->cols();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix3x3_data(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix3x3_data",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix3x3_data" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  result = (double *)(arg1)->data();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix3x3_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix3x3_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix3x3_zero" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix3x3_fillRowMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix3x3_fillRowMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix3x3_fillRowMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix3x3_fillRowMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixFixSize< 3,3 > const *)arg1)->fillRowMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix3x3_fillColMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix3x3_fillColMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix3x3_fillColMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix3x3_fillColMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixFixSize< 3,3 > const *)arg1)->fillColMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix3x3_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Matrix3x3_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix3x3_toString" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 3,3 > const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix3x3_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Matrix3x3_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix3x3_display" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 3,3 > const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix3x3_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix3x3_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix3x3_toMatlab" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  result = (mxArray *)iDynTree_MatrixFixSize_Sl_3_Sc_3_Sg__toMatlab((iDynTree::MatrixFixSize< 3,3 > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix3x3_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix3x3_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix3x3_fromMatlab" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  arg2 = argv[1];
  iDynTree_MatrixFixSize_Sl_3_Sc_3_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Matrix3x3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 3,3 > *arg1 = (iDynTree::MatrixFixSize< 3,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Matrix3x3",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matrix3x3" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 3,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 3,3 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix4x4__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::MatrixFixSize< 4,4 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix4x4",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::MatrixFixSize< 4,4 > *)new iDynTree::MatrixFixSize< 4,4 >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix4x4__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::MatrixFixSize< 4,4 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix4x4",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix4x4" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Matrix4x4" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Matrix4x4" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (iDynTree::MatrixFixSize< 4,4 > *)new iDynTree::MatrixFixSize< 4,4 >((double const *)arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix4x4__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::MatrixView< double const > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixFixSize< 4,4 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix4x4",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix4x4" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Matrix4x4" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::MatrixView< double const > * >(argp1));
    }
  }
  result = (iDynTree::MatrixFixSize< 4,4 > *)new iDynTree::MatrixFixSize< 4,4 >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix4x4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Matrix4x4__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Matrix4x4__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Matrix4x4__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Matrix4x4'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixFixSize< 4,4 >::MatrixFixSize()\n"
    "    iDynTree::MatrixFixSize< 4,4 >::MatrixFixSize(double const *,std::size_t const,std::size_t const)\n"
    "    iDynTree::MatrixFixSize< 4,4 >::MatrixFixSize(iDynTree::MatrixView< double const >)\n");
  return 1;
}


int _wrap_Matrix4x4_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Matrix4x4_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4_paren" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix4x4_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix4x4_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixFixSize< 4,4 > const *)arg1)->operator ()(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix4x4_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4_paren" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix4x4_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix4x4_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double *) &(arg1)->operator ()(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix4x4_paren__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix4x4_paren__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Matrix4x4_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixFixSize< 4,4 >::operator ()(std::size_t const,std::size_t const) const\n"
    "    iDynTree::MatrixFixSize< 4,4 >::operator ()(std::size_t const,std::size_t const)\n");
  return 1;
}


int _wrap_Matrix4x4_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Matrix4x4_getVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4_getVal" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix4x4_getVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix4x4_getVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixFixSize< 4,4 > const *)arg1)->getVal(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Matrix4x4_setVal",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4_setVal" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix4x4_setVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix4x4_setVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Matrix4x4_setVal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->setVal(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4_rows(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Matrix4x4_rows",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4_rows" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 4,4 > const *)arg1)->rows();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4_cols(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Matrix4x4_cols",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4_cols" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 4,4 > const *)arg1)->cols();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4_data(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix4x4_data",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4_data" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  result = (double *)(arg1)->data();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4_zero" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4_fillRowMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4_fillRowMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4_fillRowMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix4x4_fillRowMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixFixSize< 4,4 > const *)arg1)->fillRowMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4_fillColMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4_fillColMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4_fillColMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix4x4_fillColMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixFixSize< 4,4 > const *)arg1)->fillColMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Matrix4x4_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4_toString" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 4,4 > const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Matrix4x4_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4_display" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 4,4 > const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix4x4_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4_toMatlab" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  result = (mxArray *)iDynTree_MatrixFixSize_Sl_4_Sc_4_Sg__toMatlab((iDynTree::MatrixFixSize< 4,4 > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4_fromMatlab" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  arg2 = argv[1];
  iDynTree_MatrixFixSize_Sl_4_Sc_4_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Matrix4x4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 4,4 > *arg1 = (iDynTree::MatrixFixSize< 4,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Matrix4x4",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matrix4x4" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 4,4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 4,4 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix6x6__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::MatrixFixSize< 6,6 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix6x6",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::MatrixFixSize< 6,6 > *)new iDynTree::MatrixFixSize< 6,6 >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix6x6__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::MatrixFixSize< 6,6 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix6x6",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix6x6" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Matrix6x6" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Matrix6x6" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (iDynTree::MatrixFixSize< 6,6 > *)new iDynTree::MatrixFixSize< 6,6 >((double const *)arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix6x6__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::MatrixView< double const > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixFixSize< 6,6 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix6x6",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix6x6" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Matrix6x6" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::MatrixView< double const > * >(argp1));
    }
  }
  result = (iDynTree::MatrixFixSize< 6,6 > *)new iDynTree::MatrixFixSize< 6,6 >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix6x6(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Matrix6x6__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Matrix6x6__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Matrix6x6__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Matrix6x6'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixFixSize< 6,6 >::MatrixFixSize()\n"
    "    iDynTree::MatrixFixSize< 6,6 >::MatrixFixSize(double const *,std::size_t const,std::size_t const)\n"
    "    iDynTree::MatrixFixSize< 6,6 >::MatrixFixSize(iDynTree::MatrixView< double const >)\n");
  return 1;
}


int _wrap_Matrix6x6_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Matrix6x6_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x6_paren" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix6x6_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix6x6_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixFixSize< 6,6 > const *)arg1)->operator ()(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x6_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix6x6_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x6_paren" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix6x6_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix6x6_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double *) &(arg1)->operator ()(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x6_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix6x6_paren__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix6x6_paren__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Matrix6x6_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixFixSize< 6,6 >::operator ()(std::size_t const,std::size_t const) const\n"
    "    iDynTree::MatrixFixSize< 6,6 >::operator ()(std::size_t const,std::size_t const)\n");
  return 1;
}


int _wrap_Matrix6x6_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Matrix6x6_getVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x6_getVal" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix6x6_getVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix6x6_getVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixFixSize< 6,6 > const *)arg1)->getVal(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x6_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Matrix6x6_setVal",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x6_setVal" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix6x6_setVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix6x6_setVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Matrix6x6_setVal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->setVal(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x6_rows(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Matrix6x6_rows",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x6_rows" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 6,6 > const *)arg1)->rows();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x6_cols(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Matrix6x6_cols",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x6_cols" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 6,6 > const *)arg1)->cols();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x6_data(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix6x6_data",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x6_data" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  result = (double *)(arg1)->data();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x6_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix6x6_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x6_zero" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x6_fillRowMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix6x6_fillRowMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x6_fillRowMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix6x6_fillRowMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixFixSize< 6,6 > const *)arg1)->fillRowMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x6_fillColMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix6x6_fillColMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x6_fillColMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix6x6_fillColMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixFixSize< 6,6 > const *)arg1)->fillColMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x6_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Matrix6x6_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x6_toString" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 6,6 > const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x6_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Matrix6x6_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x6_display" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 6,6 > const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x6_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix6x6_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x6_toMatlab" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  result = (mxArray *)iDynTree_MatrixFixSize_Sl_6_Sc_6_Sg__toMatlab((iDynTree::MatrixFixSize< 6,6 > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x6_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix6x6_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x6_fromMatlab" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  arg2 = argv[1];
  iDynTree_MatrixFixSize_Sl_6_Sc_6_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Matrix6x6(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,6 > *arg1 = (iDynTree::MatrixFixSize< 6,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Matrix6x6",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matrix6x6" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,6 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix6x10__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::MatrixFixSize< 6,10 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix6x10",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::MatrixFixSize< 6,10 > *)new iDynTree::MatrixFixSize< 6,10 >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix6x10__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::MatrixFixSize< 6,10 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix6x10",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix6x10" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Matrix6x10" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Matrix6x10" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (iDynTree::MatrixFixSize< 6,10 > *)new iDynTree::MatrixFixSize< 6,10 >((double const *)arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix6x10__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::MatrixView< double const > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixFixSize< 6,10 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix6x10",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix6x10" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Matrix6x10" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::MatrixView< double const > * >(argp1));
    }
  }
  result = (iDynTree::MatrixFixSize< 6,10 > *)new iDynTree::MatrixFixSize< 6,10 >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix6x10(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Matrix6x10__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Matrix6x10__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Matrix6x10__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Matrix6x10'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixFixSize< 6,10 >::MatrixFixSize()\n"
    "    iDynTree::MatrixFixSize< 6,10 >::MatrixFixSize(double const *,std::size_t const,std::size_t const)\n"
    "    iDynTree::MatrixFixSize< 6,10 >::MatrixFixSize(iDynTree::MatrixView< double const >)\n");
  return 1;
}


int _wrap_Matrix6x10_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Matrix6x10_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x10_paren" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix6x10_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix6x10_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixFixSize< 6,10 > const *)arg1)->operator ()(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x10_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix6x10_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x10_paren" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix6x10_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix6x10_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double *) &(arg1)->operator ()(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x10_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix6x10_paren__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix6x10_paren__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Matrix6x10_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixFixSize< 6,10 >::operator ()(std::size_t const,std::size_t const) const\n"
    "    iDynTree::MatrixFixSize< 6,10 >::operator ()(std::size_t const,std::size_t const)\n");
  return 1;
}


int _wrap_Matrix6x10_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Matrix6x10_getVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x10_getVal" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix6x10_getVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix6x10_getVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixFixSize< 6,10 > const *)arg1)->getVal(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x10_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Matrix6x10_setVal",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x10_setVal" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix6x10_setVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix6x10_setVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Matrix6x10_setVal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->setVal(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x10_rows(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Matrix6x10_rows",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x10_rows" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 6,10 > const *)arg1)->rows();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x10_cols(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Matrix6x10_cols",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x10_cols" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 6,10 > const *)arg1)->cols();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x10_data(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix6x10_data",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x10_data" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  result = (double *)(arg1)->data();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x10_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix6x10_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x10_zero" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x10_fillRowMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix6x10_fillRowMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x10_fillRowMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix6x10_fillRowMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixFixSize< 6,10 > const *)arg1)->fillRowMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x10_fillColMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix6x10_fillColMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x10_fillColMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix6x10_fillColMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixFixSize< 6,10 > const *)arg1)->fillColMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x10_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Matrix6x10_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x10_toString" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 6,10 > const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x10_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Matrix6x10_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x10_display" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 6,10 > const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x10_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix6x10_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x10_toMatlab" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  result = (mxArray *)iDynTree_MatrixFixSize_Sl_6_Sc_10_Sg__toMatlab((iDynTree::MatrixFixSize< 6,10 > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix6x10_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix6x10_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix6x10_fromMatlab" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  arg2 = argv[1];
  iDynTree_MatrixFixSize_Sl_6_Sc_10_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Matrix6x10(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 6,10 > *arg1 = (iDynTree::MatrixFixSize< 6,10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Matrix6x10",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matrix6x10" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 6,10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 6,10 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix10x16__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::MatrixFixSize< 10,16 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix10x16",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::MatrixFixSize< 10,16 > *)new iDynTree::MatrixFixSize< 10,16 >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix10x16__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::MatrixFixSize< 10,16 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix10x16",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix10x16" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Matrix10x16" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Matrix10x16" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (iDynTree::MatrixFixSize< 10,16 > *)new iDynTree::MatrixFixSize< 10,16 >((double const *)arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix10x16__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::MatrixView< double const > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixFixSize< 10,16 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix10x16",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix10x16" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Matrix10x16" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::MatrixView< double const > * >(argp1));
    }
  }
  result = (iDynTree::MatrixFixSize< 10,16 > *)new iDynTree::MatrixFixSize< 10,16 >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix10x16(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Matrix10x16__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Matrix10x16__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Matrix10x16__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Matrix10x16'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixFixSize< 10,16 >::MatrixFixSize()\n"
    "    iDynTree::MatrixFixSize< 10,16 >::MatrixFixSize(double const *,std::size_t const,std::size_t const)\n"
    "    iDynTree::MatrixFixSize< 10,16 >::MatrixFixSize(iDynTree::MatrixView< double const >)\n");
  return 1;
}


int _wrap_Matrix10x16_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Matrix10x16_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix10x16_paren" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix10x16_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix10x16_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixFixSize< 10,16 > const *)arg1)->operator ()(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix10x16_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix10x16_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix10x16_paren" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix10x16_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix10x16_paren" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double *) &(arg1)->operator ()(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix10x16_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix10x16_paren__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix10x16_paren__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Matrix10x16_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixFixSize< 10,16 >::operator ()(std::size_t const,std::size_t const) const\n"
    "    iDynTree::MatrixFixSize< 10,16 >::operator ()(std::size_t const,std::size_t const)\n");
  return 1;
}


int _wrap_Matrix10x16_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Matrix10x16_getVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix10x16_getVal" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix10x16_getVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix10x16_getVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (double)((iDynTree::MatrixFixSize< 10,16 > const *)arg1)->getVal(arg2,arg3);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix10x16_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  std::size_t arg2 ;
  std::size_t arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Matrix10x16_setVal",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix10x16_setVal" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix10x16_setVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix10x16_setVal" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Matrix10x16_setVal" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->setVal(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix10x16_rows(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Matrix10x16_rows",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix10x16_rows" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 10,16 > const *)arg1)->rows();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix10x16_cols(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Matrix10x16_cols",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix10x16_cols" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 10,16 > const *)arg1)->cols();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix10x16_data(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix10x16_data",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix10x16_data" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  result = (double *)(arg1)->data();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix10x16_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix10x16_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix10x16_zero" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix10x16_fillRowMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix10x16_fillRowMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix10x16_fillRowMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix10x16_fillRowMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixFixSize< 10,16 > const *)arg1)->fillRowMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix10x16_fillColMajorBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix10x16_fillColMajorBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix10x16_fillColMajorBuffer" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix10x16_fillColMajorBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::MatrixFixSize< 10,16 > const *)arg1)->fillColMajorBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix10x16_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Matrix10x16_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix10x16_toString" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 10,16 > const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix10x16_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Matrix10x16_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix10x16_display" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  result = ((iDynTree::MatrixFixSize< 10,16 > const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix10x16_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix10x16_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix10x16_toMatlab" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  result = (mxArray *)iDynTree_MatrixFixSize_Sl_10_Sc_16_Sg__toMatlab((iDynTree::MatrixFixSize< 10,16 > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix10x16_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix10x16_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix10x16_fromMatlab" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  arg2 = argv[1];
  iDynTree_MatrixFixSize_Sl_10_Sc_16_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Matrix10x16(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixFixSize< 10,16 > *arg1 = (iDynTree::MatrixFixSize< 10,16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Matrix10x16",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matrix10x16" "', argument " "1"" of type '" "iDynTree::MatrixFixSize< 10,16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixFixSize< 10,16 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector3__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::VectorFixSize< 3 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector3",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::VectorFixSize< 3 > *)new iDynTree::VectorFixSize< 3 >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector3__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::VectorFixSize< 3 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector3",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector3" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector3" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (iDynTree::VectorFixSize< 3 > *)new iDynTree::VectorFixSize< 3 >((double const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector3__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::VectorFixSize< 3 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector3",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector3" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Vector3" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp1));
    }
  }
  result = (iDynTree::VectorFixSize< 3 > *)new iDynTree::VectorFixSize< 3 >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Vector3__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector3__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Vector3__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Vector3'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 3 >::VectorFixSize()\n"
    "    iDynTree::VectorFixSize< 3 >::VectorFixSize(double const *,std::size_t const)\n"
    "    iDynTree::VectorFixSize< 3 >::VectorFixSize(iDynTree::Span< double const,-1 >)\n");
  return 1;
}


int _wrap_Vector3_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector3_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_paren" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector3_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 3 > const *)arg1)->operator ()(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector3_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_paren" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector3_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector3_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector3_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector3_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 3 >::operator ()(std::size_t const) const\n"
    "    iDynTree::VectorFixSize< 3 >::operator ()(std::size_t const)\n");
  return 1;
}


int _wrap_Vector3_brace__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector3_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_brace" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector3_brace" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 3 > const *)arg1)->operator [](arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_brace__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector3_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_brace" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector3_brace" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double *) &(arg1)->operator [](arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_brace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector3_brace__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector3_brace__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector3_brace'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 3 >::operator [](std::size_t const) const\n"
    "    iDynTree::VectorFixSize< 3 >::operator [](std::size_t const)\n");
  return 1;
}


int _wrap_Vector3_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector3_getVal",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_getVal" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector3_getVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 3 > const *)arg1)->getVal(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  std::size_t arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Vector3_setVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_setVal" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector3_setVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector3_setVal" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->setVal(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_begin__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector3_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_begin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 3 > const *)arg1)->begin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_end__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector3_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_end" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 3 > const *)arg1)->end();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_cbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector3_cbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_cbegin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 3 > const *)arg1)->cbegin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_cend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector3_cend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_cend" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 3 > const *)arg1)->cend();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_begin__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector3_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_begin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  result = (double *)(arg1)->begin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_begin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector3_begin__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector3_begin__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector3_begin'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 3 >::begin() const\n"
    "    iDynTree::VectorFixSize< 3 >::begin()\n");
  return 1;
}


int _wrap_Vector3_end__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector3_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_end" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  result = (double *)(arg1)->end();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_end(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector3_end__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector3_end__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector3_end'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 3 >::end() const\n"
    "    iDynTree::VectorFixSize< 3 >::end()\n");
  return 1;
}


int _wrap_Vector3_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Vector3_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_size" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 3 > const *)arg1)->size();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_data(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector3_data",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_data" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  result = (double *)(arg1)->data();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector3_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_zero" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_fillBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector3_fillBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_fillBuffer" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector3_fillBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::VectorFixSize< 3 > const *)arg1)->fillBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Vector3_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_toString" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 3 > const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Vector3_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_display" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 3 > const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("Vector3_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_toMatlab" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  result = (mxArray *)iDynTree_VectorFixSize_Sl_3_Sg__toMatlab((iDynTree::VectorFixSize< 3 > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector3_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector3_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector3_fromMatlab" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  arg2 = argv[1];
  iDynTree_VectorFixSize_Sl_3_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Vector3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 3 > *arg1 = (iDynTree::VectorFixSize< 3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Vector3",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vector3" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 3 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector4__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::VectorFixSize< 4 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector4",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::VectorFixSize< 4 > *)new iDynTree::VectorFixSize< 4 >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector4__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::VectorFixSize< 4 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector4",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector4" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector4" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (iDynTree::VectorFixSize< 4 > *)new iDynTree::VectorFixSize< 4 >((double const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector4__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::VectorFixSize< 4 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector4",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector4" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Vector4" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp1));
    }
  }
  result = (iDynTree::VectorFixSize< 4 > *)new iDynTree::VectorFixSize< 4 >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Vector4__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector4__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Vector4__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Vector4'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 4 >::VectorFixSize()\n"
    "    iDynTree::VectorFixSize< 4 >::VectorFixSize(double const *,std::size_t const)\n"
    "    iDynTree::VectorFixSize< 4 >::VectorFixSize(iDynTree::Span< double const,-1 >)\n");
  return 1;
}


int _wrap_Vector4_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector4_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_paren" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector4_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 4 > const *)arg1)->operator ()(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector4_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_paren" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector4_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector4_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector4_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector4_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 4 >::operator ()(std::size_t const) const\n"
    "    iDynTree::VectorFixSize< 4 >::operator ()(std::size_t const)\n");
  return 1;
}


int _wrap_Vector4_brace__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector4_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_brace" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector4_brace" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 4 > const *)arg1)->operator [](arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_brace__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector4_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_brace" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector4_brace" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double *) &(arg1)->operator [](arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_brace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector4_brace__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector4_brace__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector4_brace'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 4 >::operator [](std::size_t const) const\n"
    "    iDynTree::VectorFixSize< 4 >::operator [](std::size_t const)\n");
  return 1;
}


int _wrap_Vector4_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector4_getVal",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_getVal" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector4_getVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 4 > const *)arg1)->getVal(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  std::size_t arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Vector4_setVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_setVal" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector4_setVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector4_setVal" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->setVal(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_begin__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector4_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_begin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 4 > const *)arg1)->begin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_end__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector4_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_end" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 4 > const *)arg1)->end();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_cbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector4_cbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_cbegin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 4 > const *)arg1)->cbegin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_cend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector4_cend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_cend" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 4 > const *)arg1)->cend();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_begin__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector4_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_begin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  result = (double *)(arg1)->begin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_begin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector4_begin__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector4_begin__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector4_begin'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 4 >::begin() const\n"
    "    iDynTree::VectorFixSize< 4 >::begin()\n");
  return 1;
}


int _wrap_Vector4_end__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector4_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_end" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  result = (double *)(arg1)->end();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_end(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector4_end__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector4_end__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector4_end'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 4 >::end() const\n"
    "    iDynTree::VectorFixSize< 4 >::end()\n");
  return 1;
}


int _wrap_Vector4_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Vector4_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_size" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 4 > const *)arg1)->size();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_data(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector4_data",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_data" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  result = (double *)(arg1)->data();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector4_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_zero" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_fillBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector4_fillBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_fillBuffer" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector4_fillBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::VectorFixSize< 4 > const *)arg1)->fillBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Vector4_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_toString" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 4 > const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Vector4_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_display" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 4 > const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("Vector4_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_toMatlab" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  result = (mxArray *)iDynTree_VectorFixSize_Sl_4_Sg__toMatlab((iDynTree::VectorFixSize< 4 > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector4_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector4_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector4_fromMatlab" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  arg2 = argv[1];
  iDynTree_VectorFixSize_Sl_4_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Vector4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 4 > *arg1 = (iDynTree::VectorFixSize< 4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Vector4",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vector4" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 4 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector6__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::VectorFixSize< 6 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector6",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::VectorFixSize< 6 > *)new iDynTree::VectorFixSize< 6 >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector6__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::VectorFixSize< 6 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector6",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector6" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector6" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (iDynTree::VectorFixSize< 6 > *)new iDynTree::VectorFixSize< 6 >((double const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector6__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::VectorFixSize< 6 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector6",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector6" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Vector6" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp1));
    }
  }
  result = (iDynTree::VectorFixSize< 6 > *)new iDynTree::VectorFixSize< 6 >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector6(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Vector6__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector6__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Vector6__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Vector6'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 6 >::VectorFixSize()\n"
    "    iDynTree::VectorFixSize< 6 >::VectorFixSize(double const *,std::size_t const)\n"
    "    iDynTree::VectorFixSize< 6 >::VectorFixSize(iDynTree::Span< double const,-1 >)\n");
  return 1;
}


int _wrap_Vector6_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector6_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_paren" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector6_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 6 > const *)arg1)->operator ()(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector6_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_paren" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector6_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector6_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector6_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector6_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 6 >::operator ()(std::size_t const) const\n"
    "    iDynTree::VectorFixSize< 6 >::operator ()(std::size_t const)\n");
  return 1;
}


int _wrap_Vector6_brace__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector6_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_brace" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector6_brace" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 6 > const *)arg1)->operator [](arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_brace__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector6_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_brace" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector6_brace" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double *) &(arg1)->operator [](arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_brace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector6_brace__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector6_brace__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector6_brace'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 6 >::operator [](std::size_t const) const\n"
    "    iDynTree::VectorFixSize< 6 >::operator [](std::size_t const)\n");
  return 1;
}


int _wrap_Vector6_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector6_getVal",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_getVal" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector6_getVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 6 > const *)arg1)->getVal(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  std::size_t arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Vector6_setVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_setVal" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector6_setVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector6_setVal" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->setVal(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_begin__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector6_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_begin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 6 > const *)arg1)->begin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_end__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector6_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_end" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 6 > const *)arg1)->end();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_cbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector6_cbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_cbegin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 6 > const *)arg1)->cbegin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_cend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector6_cend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_cend" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 6 > const *)arg1)->cend();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_begin__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector6_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_begin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  result = (double *)(arg1)->begin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_begin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector6_begin__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector6_begin__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector6_begin'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 6 >::begin() const\n"
    "    iDynTree::VectorFixSize< 6 >::begin()\n");
  return 1;
}


int _wrap_Vector6_end__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector6_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_end" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  result = (double *)(arg1)->end();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_end(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector6_end__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector6_end__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector6_end'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 6 >::end() const\n"
    "    iDynTree::VectorFixSize< 6 >::end()\n");
  return 1;
}


int _wrap_Vector6_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Vector6_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_size" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 6 > const *)arg1)->size();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_data(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector6_data",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_data" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  result = (double *)(arg1)->data();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector6_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_zero" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_fillBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector6_fillBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_fillBuffer" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector6_fillBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::VectorFixSize< 6 > const *)arg1)->fillBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Vector6_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_toString" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 6 > const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Vector6_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_display" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 6 > const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("Vector6_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_toMatlab" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  result = (mxArray *)iDynTree_VectorFixSize_Sl_6_Sg__toMatlab((iDynTree::VectorFixSize< 6 > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector6_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector6_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector6_fromMatlab" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  arg2 = argv[1];
  iDynTree_VectorFixSize_Sl_6_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Vector6(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 6 > *arg1 = (iDynTree::VectorFixSize< 6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Vector6",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vector6" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 6 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector10__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::VectorFixSize< 10 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector10",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::VectorFixSize< 10 > *)new iDynTree::VectorFixSize< 10 >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector10__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::VectorFixSize< 10 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector10",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector10" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector10" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (iDynTree::VectorFixSize< 10 > *)new iDynTree::VectorFixSize< 10 >((double const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector10__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::VectorFixSize< 10 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector10",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector10" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Vector10" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp1));
    }
  }
  result = (iDynTree::VectorFixSize< 10 > *)new iDynTree::VectorFixSize< 10 >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector10(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Vector10__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector10__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Vector10__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Vector10'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 10 >::VectorFixSize()\n"
    "    iDynTree::VectorFixSize< 10 >::VectorFixSize(double const *,std::size_t const)\n"
    "    iDynTree::VectorFixSize< 10 >::VectorFixSize(iDynTree::Span< double const,-1 >)\n");
  return 1;
}


int _wrap_Vector10_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector10_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_paren" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector10_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 10 > const *)arg1)->operator ()(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector10_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_paren" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector10_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector10_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector10_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector10_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 10 >::operator ()(std::size_t const) const\n"
    "    iDynTree::VectorFixSize< 10 >::operator ()(std::size_t const)\n");
  return 1;
}


int _wrap_Vector10_brace__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector10_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_brace" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector10_brace" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 10 > const *)arg1)->operator [](arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_brace__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector10_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_brace" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector10_brace" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double *) &(arg1)->operator [](arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_brace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector10_brace__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector10_brace__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector10_brace'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 10 >::operator [](std::size_t const) const\n"
    "    iDynTree::VectorFixSize< 10 >::operator [](std::size_t const)\n");
  return 1;
}


int _wrap_Vector10_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector10_getVal",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_getVal" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector10_getVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 10 > const *)arg1)->getVal(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  std::size_t arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Vector10_setVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_setVal" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector10_setVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector10_setVal" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->setVal(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_begin__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector10_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_begin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 10 > const *)arg1)->begin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_end__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector10_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_end" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 10 > const *)arg1)->end();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_cbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector10_cbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_cbegin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 10 > const *)arg1)->cbegin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_cend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector10_cend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_cend" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 10 > const *)arg1)->cend();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_begin__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector10_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_begin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  result = (double *)(arg1)->begin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_begin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector10_begin__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector10_begin__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector10_begin'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 10 >::begin() const\n"
    "    iDynTree::VectorFixSize< 10 >::begin()\n");
  return 1;
}


int _wrap_Vector10_end__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector10_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_end" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  result = (double *)(arg1)->end();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_end(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector10_end__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector10_end__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector10_end'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 10 >::end() const\n"
    "    iDynTree::VectorFixSize< 10 >::end()\n");
  return 1;
}


int _wrap_Vector10_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Vector10_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_size" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 10 > const *)arg1)->size();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_data(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector10_data",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_data" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  result = (double *)(arg1)->data();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector10_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_zero" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_fillBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector10_fillBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_fillBuffer" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector10_fillBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::VectorFixSize< 10 > const *)arg1)->fillBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Vector10_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_toString" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 10 > const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Vector10_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_display" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 10 > const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("Vector10_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_toMatlab" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  result = (mxArray *)iDynTree_VectorFixSize_Sl_10_Sg__toMatlab((iDynTree::VectorFixSize< 10 > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector10_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector10_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector10_fromMatlab" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  arg2 = argv[1];
  iDynTree_VectorFixSize_Sl_10_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Vector10(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 10 > *arg1 = (iDynTree::VectorFixSize< 10 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Vector10",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vector10" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 10 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 10 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector16__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::VectorFixSize< 16 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector16",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::VectorFixSize< 16 > *)new iDynTree::VectorFixSize< 16 >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector16__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::VectorFixSize< 16 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector16",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector16" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Vector16" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (iDynTree::VectorFixSize< 16 > *)new iDynTree::VectorFixSize< 16 >((double const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector16__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::VectorFixSize< 16 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Vector16",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Vector16" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Vector16" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp1));
    }
  }
  result = (iDynTree::VectorFixSize< 16 > *)new iDynTree::VectorFixSize< 16 >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Vector16(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Vector16__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector16__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Vector16__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Vector16'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 16 >::VectorFixSize()\n"
    "    iDynTree::VectorFixSize< 16 >::VectorFixSize(double const *,std::size_t const)\n"
    "    iDynTree::VectorFixSize< 16 >::VectorFixSize(iDynTree::Span< double const,-1 >)\n");
  return 1;
}


int _wrap_Vector16_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector16_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_paren" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector16_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 16 > const *)arg1)->operator ()(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector16_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_paren" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector16_paren" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector16_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector16_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector16_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 16 >::operator ()(std::size_t const) const\n"
    "    iDynTree::VectorFixSize< 16 >::operator ()(std::size_t const)\n");
  return 1;
}


int _wrap_Vector16_brace__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector16_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_brace" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector16_brace" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 16 > const *)arg1)->operator [](arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_brace__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector16_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_brace" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector16_brace" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double *) &(arg1)->operator [](arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_brace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector16_brace__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector16_brace__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector16_brace'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 16 >::operator [](std::size_t const) const\n"
    "    iDynTree::VectorFixSize< 16 >::operator [](std::size_t const)\n");
  return 1;
}


int _wrap_Vector16_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Vector16_getVal",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_getVal" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector16_getVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  result = (double)((iDynTree::VectorFixSize< 16 > const *)arg1)->getVal(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  std::size_t arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Vector16_setVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_setVal" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector16_setVal" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector16_setVal" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->setVal(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_begin__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector16_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_begin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 16 > const *)arg1)->begin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_end__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector16_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_end" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 16 > const *)arg1)->end();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_cbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector16_cbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_cbegin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 16 > const *)arg1)->cbegin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_cend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector16_cend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_cend" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  result = (double *)((iDynTree::VectorFixSize< 16 > const *)arg1)->cend();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_begin__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector16_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_begin" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  result = (double *)(arg1)->begin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_begin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector16_begin__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector16_begin__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector16_begin'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 16 >::begin() const\n"
    "    iDynTree::VectorFixSize< 16 >::begin()\n");
  return 1;
}


int _wrap_Vector16_end__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector16_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_end" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  result = (double *)(arg1)->end();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_end(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector16_end__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector16_end__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Vector16_end'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::VectorFixSize< 16 >::end() const\n"
    "    iDynTree::VectorFixSize< 16 >::end()\n");
  return 1;
}


int _wrap_Vector16_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("Vector16_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_size" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 16 > const *)arg1)->size();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_data(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("Vector16_data",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_data" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  result = (double *)(arg1)->data();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector16_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_zero" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_fillBuffer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  double *arg2 = (double *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector16_fillBuffer",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_fillBuffer" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector16_fillBuffer" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  ((iDynTree::VectorFixSize< 16 > const *)arg1)->fillBuffer(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Vector16_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_toString" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 16 > const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Vector16_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_display" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  result = ((iDynTree::VectorFixSize< 16 > const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("Vector16_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_toMatlab" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  result = (mxArray *)iDynTree_VectorFixSize_Sl_16_Sg__toMatlab((iDynTree::VectorFixSize< 16 > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Vector16_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Vector16_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector16_fromMatlab" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  arg2 = argv[1];
  iDynTree_VectorFixSize_Sl_16_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Vector16(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VectorFixSize< 16 > *arg1 = (iDynTree::VectorFixSize< 16 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Vector16",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Vector16" "', argument " "1"" of type '" "iDynTree::VectorFixSize< 16 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VectorFixSize< 16 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_PositionRaw__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::PositionRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_PositionRaw",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::PositionRaw *)new iDynTree::PositionRaw();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__PositionRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_PositionRaw__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::PositionRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_PositionRaw",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PositionRaw" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PositionRaw" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PositionRaw" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (iDynTree::PositionRaw *)new iDynTree::PositionRaw(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__PositionRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_PositionRaw__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::PositionRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_PositionRaw",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PositionRaw" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PositionRaw" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (iDynTree::PositionRaw *)new iDynTree::PositionRaw((double const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__PositionRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_PositionRaw__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PositionRaw *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::PositionRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_PositionRaw",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__PositionRaw,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PositionRaw" "', argument " "1"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PositionRaw" "', argument " "1"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PositionRaw * >(argp1);
  result = (iDynTree::PositionRaw *)new iDynTree::PositionRaw((iDynTree::PositionRaw const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__PositionRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_PositionRaw__SWIG_4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::PositionRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_PositionRaw",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PositionRaw" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PositionRaw" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp1));
    }
  }
  result = (iDynTree::PositionRaw *)new iDynTree::PositionRaw(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__PositionRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_PositionRaw(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_PositionRaw__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__PositionRaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PositionRaw__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PositionRaw__SWIG_4(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_PositionRaw__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_PositionRaw__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_PositionRaw'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::PositionRaw::PositionRaw()\n"
    "    iDynTree::PositionRaw::PositionRaw(double,double,double)\n"
    "    iDynTree::PositionRaw::PositionRaw(double const *,unsigned int const)\n"
    "    iDynTree::PositionRaw::PositionRaw(iDynTree::PositionRaw const &)\n"
    "    iDynTree::PositionRaw::PositionRaw(iDynTree::Span< double const,-1 >)\n");
  return 1;
}


int _wrap_PositionRaw_changePoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PositionRaw *arg1 = (iDynTree::PositionRaw *) 0 ;
  iDynTree::PositionRaw *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::PositionRaw *result = 0 ;
  
  if (!SWIG_check_num_args("PositionRaw_changePoint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PositionRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PositionRaw_changePoint" "', argument " "1"" of type '" "iDynTree::PositionRaw *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PositionRaw * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__PositionRaw,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PositionRaw_changePoint" "', argument " "2"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositionRaw_changePoint" "', argument " "2"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::PositionRaw * >(argp2);
  result = (iDynTree::PositionRaw *) &(arg1)->changePoint((iDynTree::PositionRaw const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__PositionRaw, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PositionRaw_changeRefPoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PositionRaw *arg1 = (iDynTree::PositionRaw *) 0 ;
  iDynTree::PositionRaw *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::PositionRaw *result = 0 ;
  
  if (!SWIG_check_num_args("PositionRaw_changeRefPoint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PositionRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PositionRaw_changeRefPoint" "', argument " "1"" of type '" "iDynTree::PositionRaw *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PositionRaw * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__PositionRaw,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PositionRaw_changeRefPoint" "', argument " "2"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositionRaw_changeRefPoint" "', argument " "2"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::PositionRaw * >(argp2);
  result = (iDynTree::PositionRaw *) &(arg1)->changeRefPoint((iDynTree::PositionRaw const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__PositionRaw, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PositionRaw_compose(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PositionRaw *arg1 = 0 ;
  iDynTree::PositionRaw *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::PositionRaw result;
  
  if (!SWIG_check_num_args("PositionRaw_compose",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__PositionRaw,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PositionRaw_compose" "', argument " "1"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositionRaw_compose" "', argument " "1"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PositionRaw * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__PositionRaw,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PositionRaw_compose" "', argument " "2"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositionRaw_compose" "', argument " "2"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::PositionRaw * >(argp2);
  result = iDynTree::PositionRaw::compose((iDynTree::PositionRaw const &)*arg1,(iDynTree::PositionRaw const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::PositionRaw(static_cast< const iDynTree::PositionRaw& >(result))), SWIGTYPE_p_iDynTree__PositionRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PositionRaw_inverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PositionRaw *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::PositionRaw result;
  
  if (!SWIG_check_num_args("PositionRaw_inverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__PositionRaw,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PositionRaw_inverse" "', argument " "1"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositionRaw_inverse" "', argument " "1"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PositionRaw * >(argp1);
  result = iDynTree::PositionRaw::inverse((iDynTree::PositionRaw const &)*arg1);
  _out = SWIG_NewPointerObj((new iDynTree::PositionRaw(static_cast< const iDynTree::PositionRaw& >(result))), SWIGTYPE_p_iDynTree__PositionRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PositionRaw_changePointOf__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PositionRaw *arg1 = (iDynTree::PositionRaw *) 0 ;
  iDynTree::SpatialMotionVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("PositionRaw_changePointOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PositionRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PositionRaw_changePointOf" "', argument " "1"" of type '" "iDynTree::PositionRaw const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PositionRaw * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PositionRaw_changePointOf" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositionRaw_changePointOf" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp2);
  result = ((iDynTree::PositionRaw const *)arg1)->changePointOf((iDynTree::SpatialMotionVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PositionRaw_changePointOf__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PositionRaw *arg1 = (iDynTree::PositionRaw *) 0 ;
  iDynTree::SpatialForceVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("PositionRaw_changePointOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PositionRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PositionRaw_changePointOf" "', argument " "1"" of type '" "iDynTree::PositionRaw const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PositionRaw * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PositionRaw_changePointOf" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositionRaw_changePointOf" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp2);
  result = ((iDynTree::PositionRaw const *)arg1)->changePointOf((iDynTree::SpatialForceVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PositionRaw_changePointOf(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__PositionRaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionVector, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PositionRaw_changePointOf__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__PositionRaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialForceVector, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PositionRaw_changePointOf__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'PositionRaw_changePointOf'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::PositionRaw::changePointOf(iDynTree::SpatialMotionVector const &) const\n"
    "    iDynTree::PositionRaw::changePointOf(iDynTree::SpatialForceVector const &) const\n");
  return 1;
}


int _wrap_PositionRaw_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PositionRaw *arg1 = (iDynTree::PositionRaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("PositionRaw_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PositionRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PositionRaw_toString" "', argument " "1"" of type '" "iDynTree::PositionRaw const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PositionRaw * >(argp1);
  result = ((iDynTree::PositionRaw const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PositionRaw_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PositionRaw *arg1 = (iDynTree::PositionRaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("PositionRaw_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PositionRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PositionRaw_display" "', argument " "1"" of type '" "iDynTree::PositionRaw const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PositionRaw * >(argp1);
  result = ((iDynTree::PositionRaw const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_PositionRaw(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PositionRaw *arg1 = (iDynTree::PositionRaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_PositionRaw",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PositionRaw, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PositionRaw" "', argument " "1"" of type '" "iDynTree::PositionRaw *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PositionRaw * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Position__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("new_Position",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Position *)new iDynTree::Position();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Position__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("new_Position",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Position" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Position" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Position" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (iDynTree::Position *)new iDynTree::Position(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Position__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("new_Position",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Position" "', argument " "1"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Position" "', argument " "1"" of type '" "iDynTree::Position const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  result = (iDynTree::Position *)new iDynTree::Position((iDynTree::Position const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Position__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PositionRaw *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("new_Position",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__PositionRaw,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Position" "', argument " "1"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Position" "', argument " "1"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PositionRaw * >(argp1);
  result = (iDynTree::Position *)new iDynTree::Position((iDynTree::PositionRaw const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Position__SWIG_4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("new_Position",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Position" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Position" "', argument " "1"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp1));
    }
  }
  result = (iDynTree::Position *)new iDynTree::Position(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Position(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Position__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Position__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__PositionRaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Position__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Position__SWIG_4(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Position__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Position'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Position::Position()\n"
    "    iDynTree::Position::Position(double,double,double)\n"
    "    iDynTree::Position::Position(iDynTree::Position const &)\n"
    "    iDynTree::Position::Position(iDynTree::PositionRaw const &)\n"
    "    iDynTree::Position::Position(iDynTree::Span< double const,-1 >)\n");
  return 1;
}


int _wrap_Position_changePoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("Position_changePoint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_changePoint" "', argument " "1"" of type '" "iDynTree::Position *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_changePoint" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_changePoint" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = (iDynTree::Position *) &(arg1)->changePoint((iDynTree::Position const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_changeRefPoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("Position_changeRefPoint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_changeRefPoint" "', argument " "1"" of type '" "iDynTree::Position *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_changeRefPoint" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_changeRefPoint" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = (iDynTree::Position *) &(arg1)->changeRefPoint((iDynTree::Position const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_changeCoordinateFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::Rotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("Position_changeCoordinateFrame",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_changeCoordinateFrame" "', argument " "1"" of type '" "iDynTree::Position *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_changeCoordinateFrame" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_changeCoordinateFrame" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Rotation * >(argp2);
  result = (iDynTree::Position *) &(arg1)->changeCoordinateFrame((iDynTree::Rotation const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_compose(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Position result;
  
  if (!SWIG_check_num_args("Position_compose",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_compose" "', argument " "1"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_compose" "', argument " "1"" of type '" "iDynTree::Position const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_compose" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_compose" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = iDynTree::Position::compose((iDynTree::Position const &)*arg1,(iDynTree::Position const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_inverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position result;
  
  if (!SWIG_check_num_args("Position_inverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_inverse" "', argument " "1"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_inverse" "', argument " "1"" of type '" "iDynTree::Position const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  result = iDynTree::Position::inverse((iDynTree::Position const &)*arg1);
  _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_changePointOf__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::SpatialMotionVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("Position_changePointOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_changePointOf" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_changePointOf" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_changePointOf" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp2);
  result = ((iDynTree::Position const *)arg1)->changePointOf((iDynTree::SpatialMotionVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_changePointOf__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::SpatialForceVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("Position_changePointOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_changePointOf" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_changePointOf" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_changePointOf" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp2);
  result = ((iDynTree::Position const *)arg1)->changePointOf((iDynTree::SpatialForceVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_changePointOf__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::Twist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("Position_changePointOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_changePointOf" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_changePointOf" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_changePointOf" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Twist * >(argp2);
  result = ((iDynTree::Position const *)arg1)->changePointOf((iDynTree::Twist const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_changePointOf__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::SpatialAcc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc result;
  
  if (!SWIG_check_num_args("Position_changePointOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_changePointOf" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_changePointOf" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_changePointOf" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialAcc * >(argp2);
  result = ((iDynTree::Position const *)arg1)->changePointOf((iDynTree::SpatialAcc const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialAcc(static_cast< const iDynTree::SpatialAcc& >(result))), SWIGTYPE_p_iDynTree__SpatialAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_changePointOf__SWIG_4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::SpatialMomentum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMomentum result;
  
  if (!SWIG_check_num_args("Position_changePointOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_changePointOf" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMomentum,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_changePointOf" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_changePointOf" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp2);
  result = ((iDynTree::Position const *)arg1)->changePointOf((iDynTree::SpatialMomentum const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMomentum(static_cast< const iDynTree::SpatialMomentum& >(result))), SWIGTYPE_p_iDynTree__SpatialMomentum, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_changePointOf__SWIG_5(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::Wrench *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Wrench result;
  
  if (!SWIG_check_num_args("Position_changePointOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_changePointOf" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_changePointOf" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_changePointOf" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Wrench * >(argp2);
  result = ((iDynTree::Position const *)arg1)->changePointOf((iDynTree::Wrench const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Wrench(static_cast< const iDynTree::Wrench& >(result))), SWIGTYPE_p_iDynTree__Wrench, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_changePointOf(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Twist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Position_changePointOf__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMomentum, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Position_changePointOf__SWIG_4(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialAcc, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Position_changePointOf__SWIG_3(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionVector, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Position_changePointOf__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Wrench, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Position_changePointOf__SWIG_5(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialForceVector, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Position_changePointOf__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Position_changePointOf'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Position::changePointOf(iDynTree::SpatialMotionVector const &) const\n"
    "    iDynTree::Position::changePointOf(iDynTree::SpatialForceVector const &) const\n"
    "    iDynTree::Position::changePointOf(iDynTree::Twist const &) const\n"
    "    iDynTree::Position::changePointOf(iDynTree::SpatialAcc const &) const\n"
    "    iDynTree::Position::changePointOf(iDynTree::SpatialMomentum const &) const\n"
    "    iDynTree::Position::changePointOf(iDynTree::Wrench const &) const\n");
  return 1;
}


int _wrap_Position_plus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Position result;
  
  if (!SWIG_check_num_args("Position_plus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_plus" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_plus" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_plus" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = ((iDynTree::Position const *)arg1)->operator +((iDynTree::Position const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_minus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Position result;
  
  if (!SWIG_check_num_args("Position_minus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_minus" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_minus" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_minus" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = ((iDynTree::Position const *)arg1)->operator -((iDynTree::Position const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_uminus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position result;
  
  if (!SWIG_check_num_args("Position_uminus",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_uminus" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  result = ((iDynTree::Position const *)arg1)->operator -();
  _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_mtimes__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::Twist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("Position_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_mtimes" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_mtimes" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_mtimes" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Twist * >(argp2);
  result = ((iDynTree::Position const *)arg1)->operator *((iDynTree::Twist const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_mtimes__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::SpatialForceVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("Position_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_mtimes" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp2);
  result = ((iDynTree::Position const *)arg1)->operator *((iDynTree::SpatialForceVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_mtimes__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::SpatialAcc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc result;
  
  if (!SWIG_check_num_args("Position_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_mtimes" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialAcc * >(argp2);
  result = ((iDynTree::Position const *)arg1)->operator *((iDynTree::SpatialAcc const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialAcc(static_cast< const iDynTree::SpatialAcc& >(result))), SWIGTYPE_p_iDynTree__SpatialAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_mtimes__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::SpatialMomentum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMomentum result;
  
  if (!SWIG_check_num_args("Position_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_mtimes" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMomentum,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp2);
  result = ((iDynTree::Position const *)arg1)->operator *((iDynTree::SpatialMomentum const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMomentum(static_cast< const iDynTree::SpatialMomentum& >(result))), SWIGTYPE_p_iDynTree__SpatialMomentum, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_mtimes__SWIG_4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  iDynTree::Wrench *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Wrench result;
  
  if (!SWIG_check_num_args("Position_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_mtimes" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position_mtimes" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position_mtimes" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Wrench * >(argp2);
  result = ((iDynTree::Position const *)arg1)->operator *((iDynTree::Wrench const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Wrench(static_cast< const iDynTree::Wrench& >(result))), SWIGTYPE_p_iDynTree__Wrench, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_mtimes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Twist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Position_mtimes__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMomentum, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Position_mtimes__SWIG_3(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialAcc, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Position_mtimes__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Wrench, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Position_mtimes__SWIG_4(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialForceVector, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Position_mtimes__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Position_mtimes'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Position::operator *(iDynTree::Twist const &) const\n"
    "    iDynTree::Position::operator *(iDynTree::SpatialForceVector const &) const\n"
    "    iDynTree::Position::operator *(iDynTree::SpatialAcc const &) const\n"
    "    iDynTree::Position::operator *(iDynTree::SpatialMomentum const &) const\n"
    "    iDynTree::Position::operator *(iDynTree::Wrench const &) const\n");
  return 1;
}


int _wrap_Position_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Position_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_toString" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  result = ((iDynTree::Position const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Position_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_display" "', argument " "1"" of type '" "iDynTree::Position const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  result = ((iDynTree::Position const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Position_Zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Position result;
  
  if (!SWIG_check_num_args("Position_Zero",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = iDynTree::Position::Zero();
  _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Position(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Position *arg1 = (iDynTree::Position *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Position",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Position" "', argument " "1"" of type '" "iDynTree::Position *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Position * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_GeomVector3__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::GeomVector3 *result = 0 ;
  
  if (!SWIG_check_num_args("new_GeomVector3",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::GeomVector3 *)new iDynTree::GeomVector3();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__GeomVector3, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_GeomVector3__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::GeomVector3 *result = 0 ;
  
  if (!SWIG_check_num_args("new_GeomVector3",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GeomVector3" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GeomVector3" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (iDynTree::GeomVector3 *)new iDynTree::GeomVector3((double const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__GeomVector3, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_GeomVector3__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::GeomVector3 *result = 0 ;
  
  if (!SWIG_check_num_args("new_GeomVector3",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeomVector3" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GeomVector3" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GeomVector3" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (iDynTree::GeomVector3 *)new iDynTree::GeomVector3(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__GeomVector3, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_GeomVector3__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Vector3 arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::GeomVector3 *result = 0 ;
  
  if (!SWIG_check_num_args("new_GeomVector3",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GeomVector3" "', argument " "1"" of type '" "iDynTree::Vector3 const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GeomVector3" "', argument " "1"" of type '" "iDynTree::Vector3 const""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::Vector3 * >(argp1));
    }
  }
  result = (iDynTree::GeomVector3 *)new iDynTree::GeomVector3(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__GeomVector3, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_GeomVector3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_GeomVector3__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GeomVector3__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_GeomVector3__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_GeomVector3__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_GeomVector3'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::GeomVector3::GeomVector3()\n"
    "    iDynTree::GeomVector3::GeomVector3(double const *,unsigned int const)\n"
    "    iDynTree::GeomVector3::GeomVector3(double const,double const,double const)\n"
    "    iDynTree::GeomVector3::GeomVector3(iDynTree::Vector3 const)\n");
  return 1;
}


int _wrap_GeomVector3_changeCoordFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GeomVector3 *arg1 = (iDynTree::GeomVector3 *) 0 ;
  iDynTree::Rotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::GeomVector3 result;
  
  if (!SWIG_check_num_args("GeomVector3_changeCoordFrame",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GeomVector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomVector3_changeCoordFrame" "', argument " "1"" of type '" "iDynTree::GeomVector3 const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GeomVector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomVector3_changeCoordFrame" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeomVector3_changeCoordFrame" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Rotation * >(argp2);
  result = ((iDynTree::GeomVector3 const *)arg1)->changeCoordFrame((iDynTree::Rotation const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::GeomVector3(static_cast< const iDynTree::GeomVector3& >(result))), SWIGTYPE_p_iDynTree__GeomVector3, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GeomVector3_compose(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GeomVector3 *arg1 = (iDynTree::GeomVector3 *) 0 ;
  iDynTree::GeomVector3 *arg2 = 0 ;
  iDynTree::GeomVector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::GeomVector3 result;
  
  if (!SWIG_check_num_args("GeomVector3_compose",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GeomVector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomVector3_compose" "', argument " "1"" of type '" "iDynTree::GeomVector3 const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GeomVector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomVector3_compose" "', argument " "2"" of type '" "iDynTree::GeomVector3 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeomVector3_compose" "', argument " "2"" of type '" "iDynTree::GeomVector3 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::GeomVector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GeomVector3_compose" "', argument " "3"" of type '" "iDynTree::GeomVector3 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeomVector3_compose" "', argument " "3"" of type '" "iDynTree::GeomVector3 const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::GeomVector3 * >(argp3);
  result = ((iDynTree::GeomVector3 const *)arg1)->compose((iDynTree::GeomVector3 const &)*arg2,(iDynTree::GeomVector3 const &)*arg3);
  _out = SWIG_NewPointerObj((new iDynTree::GeomVector3(static_cast< const iDynTree::GeomVector3& >(result))), SWIGTYPE_p_iDynTree__GeomVector3, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GeomVector3_inverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GeomVector3 *arg1 = (iDynTree::GeomVector3 *) 0 ;
  iDynTree::GeomVector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::GeomVector3 result;
  
  if (!SWIG_check_num_args("GeomVector3_inverse",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GeomVector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomVector3_inverse" "', argument " "1"" of type '" "iDynTree::GeomVector3 const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GeomVector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomVector3_inverse" "', argument " "2"" of type '" "iDynTree::GeomVector3 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeomVector3_inverse" "', argument " "2"" of type '" "iDynTree::GeomVector3 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::GeomVector3 * >(argp2);
  result = ((iDynTree::GeomVector3 const *)arg1)->inverse((iDynTree::GeomVector3 const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::GeomVector3(static_cast< const iDynTree::GeomVector3& >(result))), SWIGTYPE_p_iDynTree__GeomVector3, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GeomVector3_dot(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GeomVector3 *arg1 = (iDynTree::GeomVector3 *) 0 ;
  iDynTree::GeomVector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("GeomVector3_dot",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GeomVector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomVector3_dot" "', argument " "1"" of type '" "iDynTree::GeomVector3 const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GeomVector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomVector3_dot" "', argument " "2"" of type '" "iDynTree::GeomVector3 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeomVector3_dot" "', argument " "2"" of type '" "iDynTree::GeomVector3 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::GeomVector3 * >(argp2);
  result = (double)((iDynTree::GeomVector3 const *)arg1)->dot((iDynTree::GeomVector3 const &)*arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GeomVector3_plus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GeomVector3 *arg1 = (iDynTree::GeomVector3 *) 0 ;
  iDynTree::GeomVector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::GeomVector3 result;
  
  if (!SWIG_check_num_args("GeomVector3_plus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GeomVector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomVector3_plus" "', argument " "1"" of type '" "iDynTree::GeomVector3 const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GeomVector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomVector3_plus" "', argument " "2"" of type '" "iDynTree::GeomVector3 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeomVector3_plus" "', argument " "2"" of type '" "iDynTree::GeomVector3 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::GeomVector3 * >(argp2);
  result = ((iDynTree::GeomVector3 const *)arg1)->operator +((iDynTree::GeomVector3 const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::GeomVector3(static_cast< const iDynTree::GeomVector3& >(result))), SWIGTYPE_p_iDynTree__GeomVector3, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GeomVector3_minus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GeomVector3 *arg1 = (iDynTree::GeomVector3 *) 0 ;
  iDynTree::GeomVector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::GeomVector3 result;
  
  if (!SWIG_check_num_args("GeomVector3_minus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GeomVector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomVector3_minus" "', argument " "1"" of type '" "iDynTree::GeomVector3 const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GeomVector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomVector3_minus" "', argument " "2"" of type '" "iDynTree::GeomVector3 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeomVector3_minus" "', argument " "2"" of type '" "iDynTree::GeomVector3 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::GeomVector3 * >(argp2);
  result = ((iDynTree::GeomVector3 const *)arg1)->operator -((iDynTree::GeomVector3 const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::GeomVector3(static_cast< const iDynTree::GeomVector3& >(result))), SWIGTYPE_p_iDynTree__GeomVector3, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GeomVector3_uminus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GeomVector3 *arg1 = (iDynTree::GeomVector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::GeomVector3 result;
  
  if (!SWIG_check_num_args("GeomVector3_uminus",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GeomVector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomVector3_uminus" "', argument " "1"" of type '" "iDynTree::GeomVector3 const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GeomVector3 * >(argp1);
  result = ((iDynTree::GeomVector3 const *)arg1)->operator -();
  _out = SWIG_NewPointerObj((new iDynTree::GeomVector3(static_cast< const iDynTree::GeomVector3& >(result))), SWIGTYPE_p_iDynTree__GeomVector3, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GeomVector3_exp(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GeomVector3 *arg1 = (iDynTree::GeomVector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Rotation result;
  
  if (!SWIG_check_num_args("GeomVector3_exp",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GeomVector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomVector3_exp" "', argument " "1"" of type '" "iDynTree::GeomVector3 const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GeomVector3 * >(argp1);
  result = ((iDynTree::GeomVector3 const *)arg1)->exp();
  _out = SWIG_NewPointerObj((new iDynTree::Rotation(static_cast< const iDynTree::Rotation& >(result))), SWIGTYPE_p_iDynTree__Rotation, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GeomVector3_cross(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GeomVector3 *arg1 = (iDynTree::GeomVector3 *) 0 ;
  iDynTree::GeomVector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::GeomVector3 result;
  
  if (!SWIG_check_num_args("GeomVector3_cross",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GeomVector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeomVector3_cross" "', argument " "1"" of type '" "iDynTree::GeomVector3 const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GeomVector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeomVector3_cross" "', argument " "2"" of type '" "iDynTree::GeomVector3 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeomVector3_cross" "', argument " "2"" of type '" "iDynTree::GeomVector3 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::GeomVector3 * >(argp2);
  result = ((iDynTree::GeomVector3 const *)arg1)->cross((iDynTree::GeomVector3 const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::GeomVector3(static_cast< const iDynTree::GeomVector3& >(result))), SWIGTYPE_p_iDynTree__GeomVector3, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_GeomVector3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GeomVector3 *arg1 = (iDynTree::GeomVector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_GeomVector3",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GeomVector3, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeomVector3" "', argument " "1"" of type '" "iDynTree::GeomVector3 *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GeomVector3 * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialMotionVectorBase__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialMotionVectorBase",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *)new iDynTree::SpatialVector< iDynTree::SpatialMotionVector >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialMotionVectorBase__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::LinearVector3T *arg1 = 0 ;
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::AngularVector3T *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialMotionVectorBase",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__LinearVector3Type,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialMotionVectorBase" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::LinearVector3T const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialMotionVectorBase" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::LinearVector3T const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::LinearVector3T * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__AngularVector3Type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpatialMotionVectorBase" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::AngularVector3T const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialMotionVectorBase" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::AngularVector3T const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::AngularVector3T * >(argp2);
  result = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *)new iDynTree::SpatialVector< iDynTree::SpatialMotionVector >((iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::LinearVector3T const &)*arg1,(iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::AngularVector3T const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialMotionVectorBase__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialMotionVectorBase",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialMotionVectorBase" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialMotionVectorBase" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  result = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *)new iDynTree::SpatialVector< iDynTree::SpatialMotionVector >((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialMotionVectorBase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_SpatialMotionVectorBase__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpatialMotionVectorBase__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__LinearVector3Type, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__AngularVector3Type, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SpatialMotionVectorBase__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_SpatialMotionVectorBase'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::SpatialVector()\n"
    "    iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::SpatialVector(iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::LinearVector3T const &,iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::AngularVector3T const &)\n"
    "    iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::SpatialVector(iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const &)\n");
  return 1;
}


int _wrap_SpatialMotionVectorBase_getLinearVec3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::LinearVector3T *result = 0 ;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_getLinearVec3",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_getLinearVec3" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  result = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::LinearVector3T *) &(arg1)->getLinearVec3();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__LinearVector3Type, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_getAngularVec3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::AngularVector3T *result = 0 ;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_getAngularVec3",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_getAngularVec3" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  result = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::AngularVector3T *) &(arg1)->getAngularVec3();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__AngularVector3Type, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_setLinearVec3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::LinearVector3T *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_setLinearVec3",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_setLinearVec3" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__LinearVector3Type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialMotionVectorBase_setLinearVec3" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::LinearVector3T const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialMotionVectorBase_setLinearVec3" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::LinearVector3T const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::LinearVector3T * >(argp2);
  (arg1)->setLinearVec3((iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::LinearVector3T const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_setAngularVec3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::AngularVector3T *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_setAngularVec3",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_setAngularVec3" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__AngularVector3Type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialMotionVectorBase_setAngularVec3" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::AngularVector3T const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialMotionVectorBase_setAngularVec3" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::AngularVector3T const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::AngularVector3T * >(argp2);
  (arg1)->setAngularVec3((iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::AngularVector3T const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_paren" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialMotionVectorBase_paren" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (double *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_getVal",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_getVal" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialMotionVectorBase_getVal" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (double)((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *)arg1)->getVal(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  unsigned int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_setVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_setVal" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialMotionVectorBase_setVal" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialMotionVectorBase_setVal" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->setVal(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_size" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  result = (unsigned int)((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *)arg1)->size();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_zero" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_changePoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_changePoint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_changePoint" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialMotionVectorBase_changePoint" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialMotionVectorBase_changePoint" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = (arg1)->changePoint((iDynTree::Position const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_changeCoordFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  iDynTree::Rotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_changeCoordFrame",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_changeCoordFrame" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialMotionVectorBase_changeCoordFrame" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialMotionVectorBase_changeCoordFrame" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Rotation * >(argp2);
  result = (arg1)->changeCoordFrame((iDynTree::Rotation const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_compose(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMotionVector *arg1 = 0 ;
  iDynTree::SpatialMotionVector *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_compose",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_compose" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialMotionVectorBase_compose" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialMotionVectorBase_compose" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialMotionVectorBase_compose" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp2);
  result = iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::SWIGTEMPLATEDISAMBIGUATOR compose((iDynTree::SpatialMotionVector const &)*arg1,(iDynTree::SpatialMotionVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_inverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMotionVector *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_inverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_inverse" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialMotionVectorBase_inverse" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp1);
  result = iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::SWIGTEMPLATEDISAMBIGUATOR inverse((iDynTree::SpatialMotionVector const &)*arg1);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_dot(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::DualVectorT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_dot",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_dot" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialMotionVectorBase_dot" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::DualVectorT const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialMotionVectorBase_dot" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::DualVectorT const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::DualVectorT * >(argp2);
  result = (double)((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *)arg1)->dot((iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::DualVectorT const &)*arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_plus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  iDynTree::SpatialMotionVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_plus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_plus" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialMotionVectorBase_plus" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialMotionVectorBase_plus" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp2);
  result = ((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *)arg1)->operator +((iDynTree::SpatialMotionVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_minus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  iDynTree::SpatialMotionVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_minus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_minus" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialMotionVectorBase_minus" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialMotionVectorBase_minus" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp2);
  result = ((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *)arg1)->operator -((iDynTree::SpatialMotionVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_uminus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_uminus",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_uminus" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  result = ((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *)arg1)->operator -();
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_Zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_Zero",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::SWIGTEMPLATEDISAMBIGUATOR Zero();
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_asVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Vector6 result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_asVector",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_asVector" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  result = ((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *)arg1)->asVector();
  _out = SWIG_NewPointerObj((new iDynTree::Vector6(static_cast< const iDynTree::Vector6& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_toString" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  result = ((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_display" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  result = ((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_toMatlab" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  result = (mxArray *)iDynTree_SpatialVector_Sl_iDynTree_SpatialMotionVector_Sg__toMatlab((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVectorBase_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SpatialMotionVectorBase_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVectorBase_fromMatlab" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  arg2 = argv[1];
  iDynTree_SpatialVector_Sl_iDynTree_SpatialMotionVector_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_SpatialMotionVectorBase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SpatialMotionVectorBase",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpatialMotionVectorBase" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialForceVectorBase__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialForceVectorBase",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *)new iDynTree::SpatialVector< iDynTree::SpatialForceVector >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialForceVectorBase__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector >::LinearVector3T *arg1 = 0 ;
  iDynTree::SpatialVector< iDynTree::SpatialForceVector >::AngularVector3T *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialForceVectorBase",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialForceVectorBase" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector >::LinearVector3T const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialForceVectorBase" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector >::LinearVector3T const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector >::LinearVector3T * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpatialForceVectorBase" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector >::AngularVector3T const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialForceVectorBase" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector >::AngularVector3T const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector >::AngularVector3T * >(argp2);
  result = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *)new iDynTree::SpatialVector< iDynTree::SpatialForceVector >((iDynTree::SpatialVector< iDynTree::SpatialForceVector >::LinearVector3T const &)*arg1,(iDynTree::SpatialVector< iDynTree::SpatialForceVector >::AngularVector3T const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialForceVectorBase__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialForceVectorBase",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialForceVectorBase" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialForceVectorBase" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  result = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *)new iDynTree::SpatialVector< iDynTree::SpatialForceVector >((iDynTree::SpatialVector< iDynTree::SpatialForceVector > const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialForceVectorBase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_SpatialForceVectorBase__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpatialForceVectorBase__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SpatialForceVectorBase__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_SpatialForceVectorBase'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SpatialVector< iDynTree::SpatialForceVector >::SpatialVector()\n"
    "    iDynTree::SpatialVector< iDynTree::SpatialForceVector >::SpatialVector(iDynTree::SpatialVector< iDynTree::SpatialForceVector >::LinearVector3T const &,iDynTree::SpatialVector< iDynTree::SpatialForceVector >::AngularVector3T const &)\n"
    "    iDynTree::SpatialVector< iDynTree::SpatialForceVector >::SpatialVector(iDynTree::SpatialVector< iDynTree::SpatialForceVector > const &)\n");
  return 1;
}


int _wrap_SpatialForceVectorBase_getLinearVec3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialVector< iDynTree::SpatialForceVector >::LinearVector3T *result = 0 ;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_getLinearVec3",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_getLinearVec3" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  result = (iDynTree::SpatialVector< iDynTree::SpatialForceVector >::LinearVector3T *) &(arg1)->getLinearVec3();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_getAngularVec3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialVector< iDynTree::SpatialForceVector >::AngularVector3T *result = 0 ;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_getAngularVec3",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_getAngularVec3" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  result = (iDynTree::SpatialVector< iDynTree::SpatialForceVector >::AngularVector3T *) &(arg1)->getAngularVec3();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_setLinearVec3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  iDynTree::SpatialVector< iDynTree::SpatialForceVector >::LinearVector3T *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_setLinearVec3",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_setLinearVec3" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialForceVectorBase_setLinearVec3" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector >::LinearVector3T const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialForceVectorBase_setLinearVec3" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector >::LinearVector3T const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector >::LinearVector3T * >(argp2);
  (arg1)->setLinearVec3((iDynTree::SpatialVector< iDynTree::SpatialForceVector >::LinearVector3T const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_setAngularVec3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  iDynTree::SpatialVector< iDynTree::SpatialForceVector >::AngularVector3T *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_setAngularVec3",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_setAngularVec3" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialForceVectorBase_setAngularVec3" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector >::AngularVector3T const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialForceVectorBase_setAngularVec3" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector >::AngularVector3T const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector >::AngularVector3T * >(argp2);
  (arg1)->setAngularVec3((iDynTree::SpatialVector< iDynTree::SpatialForceVector >::AngularVector3T const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double *result = 0 ;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_paren" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialForceVectorBase_paren" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (double *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_getVal",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_getVal" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialForceVectorBase_getVal" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (double)((iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *)arg1)->getVal(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  unsigned int arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_setVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_setVal" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialForceVectorBase_setVal" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SpatialForceVectorBase_setVal" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->setVal(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_size" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  result = (unsigned int)((iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *)arg1)->size();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_zero" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_changePoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_changePoint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_changePoint" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialForceVectorBase_changePoint" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialForceVectorBase_changePoint" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = (arg1)->changePoint((iDynTree::Position const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_changeCoordFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  iDynTree::Rotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_changeCoordFrame",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_changeCoordFrame" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialForceVectorBase_changeCoordFrame" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialForceVectorBase_changeCoordFrame" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Rotation * >(argp2);
  result = (arg1)->changeCoordFrame((iDynTree::Rotation const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_compose(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialForceVector *arg1 = 0 ;
  iDynTree::SpatialForceVector *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_compose",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_compose" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialForceVectorBase_compose" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialForceVectorBase_compose" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialForceVectorBase_compose" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp2);
  result = iDynTree::SpatialVector< iDynTree::SpatialForceVector >::SWIGTEMPLATEDISAMBIGUATOR compose((iDynTree::SpatialForceVector const &)*arg1,(iDynTree::SpatialForceVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_inverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialForceVector *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_inverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_inverse" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialForceVectorBase_inverse" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp1);
  result = iDynTree::SpatialVector< iDynTree::SpatialForceVector >::SWIGTEMPLATEDISAMBIGUATOR inverse((iDynTree::SpatialForceVector const &)*arg1);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_dot(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  iDynTree::SpatialVector< iDynTree::SpatialForceVector >::DualVectorT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_dot",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_dot" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialForceVectorBase_dot" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector >::DualVectorT const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialForceVectorBase_dot" "', argument " "2"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector >::DualVectorT const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector >::DualVectorT * >(argp2);
  result = (double)((iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *)arg1)->dot((iDynTree::SpatialVector< iDynTree::SpatialForceVector >::DualVectorT const &)*arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_plus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  iDynTree::SpatialForceVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_plus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_plus" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialForceVectorBase_plus" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialForceVectorBase_plus" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp2);
  result = ((iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *)arg1)->operator +((iDynTree::SpatialForceVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_minus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  iDynTree::SpatialForceVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_minus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_minus" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialForceVectorBase_minus" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialForceVectorBase_minus" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp2);
  result = ((iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *)arg1)->operator -((iDynTree::SpatialForceVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_uminus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_uminus",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_uminus" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  result = ((iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *)arg1)->operator -();
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_Zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_Zero",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = iDynTree::SpatialVector< iDynTree::SpatialForceVector >::SWIGTEMPLATEDISAMBIGUATOR Zero();
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_asVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Vector6 result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_asVector",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_asVector" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  result = ((iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *)arg1)->asVector();
  _out = SWIG_NewPointerObj((new iDynTree::Vector6(static_cast< const iDynTree::Vector6& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_toString" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  result = ((iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_display" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  result = ((iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_toMatlab" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  result = (mxArray *)iDynTree_SpatialVector_Sl_iDynTree_SpatialForceVector_Sg__toMatlab((iDynTree::SpatialVector< iDynTree::SpatialForceVector > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVectorBase_fromMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  mxArray *arg2 = (mxArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SpatialForceVectorBase_fromMatlab",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVectorBase_fromMatlab" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  arg2 = argv[1];
  iDynTree_SpatialVector_Sl_iDynTree_SpatialForceVector_Sg__fromMatlab(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_SpatialForceVectorBase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = (iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SpatialForceVectorBase",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpatialForceVectorBase" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Dummy(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Dummy *result = 0 ;
  
  if (!SWIG_check_num_args("new_Dummy",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Dummy *)new iDynTree::Dummy();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Dummy, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Dummy(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Dummy *arg1 = (iDynTree::Dummy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Dummy",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Dummy, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dummy" "', argument " "1"" of type '" "iDynTree::Dummy *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Dummy * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialMotionVector__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SpatialMotionVector *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialMotionVector",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::SpatialMotionVector *)new iDynTree::SpatialMotionVector();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialMotionVector, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialMotionVector__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinearMotionVector3 *arg1 = 0 ;
  iDynTree::AngularMotionVector3 *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialMotionVector",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialMotionVector" "', argument " "1"" of type '" "iDynTree::LinearMotionVector3 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialMotionVector" "', argument " "1"" of type '" "iDynTree::LinearMotionVector3 const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinearMotionVector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpatialMotionVector" "', argument " "2"" of type '" "iDynTree::AngularMotionVector3 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialMotionVector" "', argument " "2"" of type '" "iDynTree::AngularMotionVector3 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::AngularMotionVector3 * >(argp2);
  result = (iDynTree::SpatialMotionVector *)new iDynTree::SpatialMotionVector((iDynTree::LinearMotionVector3 const &)*arg1,(iDynTree::AngularMotionVector3 const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialMotionVector, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialMotionVector__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMotionVector *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialMotionVector",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialMotionVector" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialMotionVector" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp1);
  result = (iDynTree::SpatialMotionVector *)new iDynTree::SpatialMotionVector((iDynTree::SpatialMotionVector const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialMotionVector, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialMotionVector__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialMotionVector",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialMotionVector" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialMotionVector" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialMotionVector > * >(argp1);
  result = (iDynTree::SpatialMotionVector *)new iDynTree::SpatialMotionVector((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialMotionVector, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialMotionVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_SpatialMotionVector__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionVector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpatialMotionVector__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpatialMotionVector__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__GeomVector3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__GeomVector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SpatialMotionVector__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_SpatialMotionVector'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SpatialMotionVector::SpatialMotionVector()\n"
    "    iDynTree::SpatialMotionVector::SpatialMotionVector(iDynTree::LinearMotionVector3 const &,iDynTree::AngularMotionVector3 const &)\n"
    "    iDynTree::SpatialMotionVector::SpatialMotionVector(iDynTree::SpatialMotionVector const &)\n"
    "    iDynTree::SpatialMotionVector::SpatialMotionVector(iDynTree::SpatialVector< iDynTree::SpatialMotionVector > const &)\n");
  return 1;
}


int _wrap_SpatialMotionVector_mtimes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMotionVector *arg1 = (iDynTree::SpatialMotionVector *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("SpatialMotionVector_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialMotionVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVector_mtimes" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialMotionVector_mtimes" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((iDynTree::SpatialMotionVector const *)arg1)->operator *(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVector_cross__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMotionVector *arg1 = (iDynTree::SpatialMotionVector *) 0 ;
  iDynTree::SpatialMotionVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("SpatialMotionVector_cross",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialMotionVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVector_cross" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialMotionVector_cross" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialMotionVector_cross" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp2);
  result = ((iDynTree::SpatialMotionVector const *)arg1)->cross((iDynTree::SpatialMotionVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVector_cross__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMotionVector *arg1 = (iDynTree::SpatialMotionVector *) 0 ;
  iDynTree::SpatialForceVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("SpatialMotionVector_cross",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialMotionVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVector_cross" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialMotionVector_cross" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialMotionVector_cross" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp2);
  result = ((iDynTree::SpatialMotionVector const *)arg1)->cross((iDynTree::SpatialForceVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVector_cross(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionVector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionVector, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpatialMotionVector_cross__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionVector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialForceVector, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpatialMotionVector_cross__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SpatialMotionVector_cross'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SpatialMotionVector::cross(iDynTree::SpatialMotionVector const &) const\n"
    "    iDynTree::SpatialMotionVector::cross(iDynTree::SpatialForceVector const &) const\n");
  return 1;
}


int _wrap_SpatialMotionVector_asCrossProductMatrix(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMotionVector *arg1 = (iDynTree::SpatialMotionVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix6x6 result;
  
  if (!SWIG_check_num_args("SpatialMotionVector_asCrossProductMatrix",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialMotionVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVector_asCrossProductMatrix" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp1);
  result = ((iDynTree::SpatialMotionVector const *)arg1)->asCrossProductMatrix();
  _out = SWIG_NewPointerObj((new iDynTree::Matrix6x6(static_cast< const iDynTree::Matrix6x6& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVector_asCrossProductMatrixWrench(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMotionVector *arg1 = (iDynTree::SpatialMotionVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix6x6 result;
  
  if (!SWIG_check_num_args("SpatialMotionVector_asCrossProductMatrixWrench",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialMotionVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVector_asCrossProductMatrixWrench" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp1);
  result = ((iDynTree::SpatialMotionVector const *)arg1)->asCrossProductMatrixWrench();
  _out = SWIG_NewPointerObj((new iDynTree::Matrix6x6(static_cast< const iDynTree::Matrix6x6& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMotionVector_exp(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMotionVector *arg1 = (iDynTree::SpatialMotionVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("SpatialMotionVector_exp",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialMotionVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMotionVector_exp" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp1);
  result = ((iDynTree::SpatialMotionVector const *)arg1)->exp();
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_SpatialMotionVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMotionVector *arg1 = (iDynTree::SpatialMotionVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SpatialMotionVector",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpatialMotionVector" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialForceVector__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SpatialForceVector *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialForceVector",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::SpatialForceVector *)new iDynTree::SpatialForceVector();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialForceVector, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialForceVector__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialForceVector::LinearVector3T *arg1 = 0 ;
  iDynTree::SpatialForceVector::AngularVector3T *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialForceVector",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialForceVector" "', argument " "1"" of type '" "iDynTree::SpatialForceVector::LinearVector3T const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialForceVector" "', argument " "1"" of type '" "iDynTree::SpatialForceVector::LinearVector3T const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialForceVector::LinearVector3T * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpatialForceVector" "', argument " "2"" of type '" "iDynTree::SpatialForceVector::AngularVector3T const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialForceVector" "', argument " "2"" of type '" "iDynTree::SpatialForceVector::AngularVector3T const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialForceVector::AngularVector3T * >(argp2);
  result = (iDynTree::SpatialForceVector *)new iDynTree::SpatialForceVector((iDynTree::SpatialForceVector::LinearVector3T const &)*arg1,(iDynTree::SpatialForceVector::AngularVector3T const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialForceVector, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialForceVector__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialForceVector *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialForceVector",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialForceVector" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialForceVector" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp1);
  result = (iDynTree::SpatialForceVector *)new iDynTree::SpatialForceVector((iDynTree::SpatialForceVector const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialForceVector, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialForceVector__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialVector< iDynTree::SpatialForceVector > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialForceVector",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialForceVector" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialForceVector" "', argument " "1"" of type '" "iDynTree::SpatialVector< iDynTree::SpatialForceVector > const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialVector< iDynTree::SpatialForceVector > * >(argp1);
  result = (iDynTree::SpatialForceVector *)new iDynTree::SpatialForceVector((iDynTree::SpatialVector< iDynTree::SpatialForceVector > const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialForceVector, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialForceVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_SpatialForceVector__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialForceVector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpatialForceVector__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpatialForceVector__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SpatialForceVector__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_SpatialForceVector'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SpatialForceVector::SpatialForceVector()\n"
    "    iDynTree::SpatialForceVector::SpatialForceVector(iDynTree::SpatialForceVector::LinearVector3T const &,iDynTree::SpatialForceVector::AngularVector3T const &)\n"
    "    iDynTree::SpatialForceVector::SpatialForceVector(iDynTree::SpatialForceVector const &)\n"
    "    iDynTree::SpatialForceVector::SpatialForceVector(iDynTree::SpatialVector< iDynTree::SpatialForceVector > const &)\n");
  return 1;
}


int _wrap_delete_SpatialForceVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialForceVector *arg1 = (iDynTree::SpatialForceVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SpatialForceVector",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpatialForceVector" "', argument " "1"" of type '" "iDynTree::SpatialForceVector *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialForceVector_mtimes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialForceVector *arg1 = (iDynTree::SpatialForceVector *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("SpatialForceVector_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialForceVector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialForceVector_mtimes" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialForceVector_mtimes" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((iDynTree::SpatialForceVector const *)arg1)->operator *(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Twist__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Twist *result = 0 ;
  
  if (!SWIG_check_num_args("new_Twist",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Twist *)new iDynTree::Twist();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Twist, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Twist__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinVelocity *arg1 = 0 ;
  iDynTree::AngVelocity *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Twist *result = 0 ;
  
  if (!SWIG_check_num_args("new_Twist",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Twist" "', argument " "1"" of type '" "iDynTree::LinVelocity const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Twist" "', argument " "1"" of type '" "iDynTree::LinVelocity const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinVelocity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Twist" "', argument " "2"" of type '" "iDynTree::AngVelocity const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Twist" "', argument " "2"" of type '" "iDynTree::AngVelocity const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::AngVelocity * >(argp2);
  result = (iDynTree::Twist *)new iDynTree::Twist((iDynTree::LinVelocity const &)*arg1,(iDynTree::AngVelocity const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Twist, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Twist__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMotionVector *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Twist *result = 0 ;
  
  if (!SWIG_check_num_args("new_Twist",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Twist" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Twist" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp1);
  result = (iDynTree::Twist *)new iDynTree::Twist((iDynTree::SpatialMotionVector const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Twist, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Twist__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Twist *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Twist *result = 0 ;
  
  if (!SWIG_check_num_args("new_Twist",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Twist" "', argument " "1"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Twist" "', argument " "1"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Twist * >(argp1);
  result = (iDynTree::Twist *)new iDynTree::Twist((iDynTree::Twist const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Twist, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Twist(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Twist__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Twist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Twist__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionVector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Twist__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__GeomVector3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__GeomVector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Twist__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Twist'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Twist::Twist()\n"
    "    iDynTree::Twist::Twist(iDynTree::LinVelocity const &,iDynTree::AngVelocity const &)\n"
    "    iDynTree::Twist::Twist(iDynTree::SpatialMotionVector const &)\n"
    "    iDynTree::Twist::Twist(iDynTree::Twist const &)\n");
  return 1;
}


int _wrap_Twist_plus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Twist *arg1 = (iDynTree::Twist *) 0 ;
  iDynTree::Twist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("Twist_plus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Twist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Twist_plus" "', argument " "1"" of type '" "iDynTree::Twist const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Twist * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Twist_plus" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Twist_plus" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Twist * >(argp2);
  result = ((iDynTree::Twist const *)arg1)->operator +((iDynTree::Twist const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Twist_minus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Twist *arg1 = (iDynTree::Twist *) 0 ;
  iDynTree::Twist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("Twist_minus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Twist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Twist_minus" "', argument " "1"" of type '" "iDynTree::Twist const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Twist * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Twist_minus" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Twist_minus" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Twist * >(argp2);
  result = ((iDynTree::Twist const *)arg1)->operator -((iDynTree::Twist const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Twist_uminus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Twist *arg1 = (iDynTree::Twist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("Twist_uminus",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Twist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Twist_uminus" "', argument " "1"" of type '" "iDynTree::Twist const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Twist * >(argp1);
  result = ((iDynTree::Twist const *)arg1)->operator -();
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Twist_mtimes__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Twist *arg1 = (iDynTree::Twist *) 0 ;
  iDynTree::Twist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc result;
  
  if (!SWIG_check_num_args("Twist_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Twist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Twist_mtimes" "', argument " "1"" of type '" "iDynTree::Twist const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Twist * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Twist_mtimes" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Twist_mtimes" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Twist * >(argp2);
  result = ((iDynTree::Twist const *)arg1)->operator *((iDynTree::Twist const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialAcc(static_cast< const iDynTree::SpatialAcc& >(result))), SWIGTYPE_p_iDynTree__SpatialAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Twist_mtimes__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Twist *arg1 = (iDynTree::Twist *) 0 ;
  iDynTree::SpatialMomentum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Wrench result;
  
  if (!SWIG_check_num_args("Twist_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Twist, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Twist_mtimes" "', argument " "1"" of type '" "iDynTree::Twist const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Twist * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMomentum,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Twist_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Twist_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp2);
  result = ((iDynTree::Twist const *)arg1)->operator *((iDynTree::SpatialMomentum const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Wrench(static_cast< const iDynTree::Wrench& >(result))), SWIGTYPE_p_iDynTree__Wrench, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Twist_mtimes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Twist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Twist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Twist_mtimes__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Twist, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMomentum, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Twist_mtimes__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Twist_mtimes'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Twist::operator *(iDynTree::Twist const &) const\n"
    "    iDynTree::Twist::operator *(iDynTree::SpatialMomentum const &) const\n");
  return 1;
}


int _wrap_delete_Twist(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Twist *arg1 = (iDynTree::Twist *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Twist",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Twist" "', argument " "1"" of type '" "iDynTree::Twist *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Twist * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Wrench__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Wrench *result = 0 ;
  
  if (!SWIG_check_num_args("new_Wrench",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Wrench *)new iDynTree::Wrench();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Wrench, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Wrench__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Force *arg1 = 0 ;
  iDynTree::Torque *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Wrench *result = 0 ;
  
  if (!SWIG_check_num_args("new_Wrench",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Wrench" "', argument " "1"" of type '" "iDynTree::Force const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Wrench" "', argument " "1"" of type '" "iDynTree::Force const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Force * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Wrench" "', argument " "2"" of type '" "iDynTree::Torque const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Wrench" "', argument " "2"" of type '" "iDynTree::Torque const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Torque * >(argp2);
  result = (iDynTree::Wrench *)new iDynTree::Wrench((iDynTree::Force const &)*arg1,(iDynTree::Torque const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Wrench, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Wrench__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialForceVector *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Wrench *result = 0 ;
  
  if (!SWIG_check_num_args("new_Wrench",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Wrench" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Wrench" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp1);
  result = (iDynTree::Wrench *)new iDynTree::Wrench((iDynTree::SpatialForceVector const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Wrench, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Wrench__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Wrench *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Wrench *result = 0 ;
  
  if (!SWIG_check_num_args("new_Wrench",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Wrench" "', argument " "1"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Wrench" "', argument " "1"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Wrench * >(argp1);
  result = (iDynTree::Wrench *)new iDynTree::Wrench((iDynTree::Wrench const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Wrench, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Wrench(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Wrench__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Wrench, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Wrench__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialForceVector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Wrench__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__GeomVector3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__GeomVector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Wrench__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Wrench'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Wrench::Wrench()\n"
    "    iDynTree::Wrench::Wrench(iDynTree::Force const &,iDynTree::Torque const &)\n"
    "    iDynTree::Wrench::Wrench(iDynTree::SpatialForceVector const &)\n"
    "    iDynTree::Wrench::Wrench(iDynTree::Wrench const &)\n");
  return 1;
}


int _wrap_Wrench_plus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Wrench *arg1 = (iDynTree::Wrench *) 0 ;
  iDynTree::Wrench *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Wrench result;
  
  if (!SWIG_check_num_args("Wrench_plus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Wrench, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrench_plus" "', argument " "1"" of type '" "iDynTree::Wrench const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Wrench * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wrench_plus" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Wrench_plus" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Wrench * >(argp2);
  result = ((iDynTree::Wrench const *)arg1)->operator +((iDynTree::Wrench const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Wrench(static_cast< const iDynTree::Wrench& >(result))), SWIGTYPE_p_iDynTree__Wrench, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Wrench_minus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Wrench *arg1 = (iDynTree::Wrench *) 0 ;
  iDynTree::Wrench *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Wrench result;
  
  if (!SWIG_check_num_args("Wrench_minus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Wrench, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrench_minus" "', argument " "1"" of type '" "iDynTree::Wrench const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Wrench * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Wrench_minus" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Wrench_minus" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Wrench * >(argp2);
  result = ((iDynTree::Wrench const *)arg1)->operator -((iDynTree::Wrench const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Wrench(static_cast< const iDynTree::Wrench& >(result))), SWIGTYPE_p_iDynTree__Wrench, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Wrench_uminus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Wrench *arg1 = (iDynTree::Wrench *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Wrench result;
  
  if (!SWIG_check_num_args("Wrench_uminus",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Wrench, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Wrench_uminus" "', argument " "1"" of type '" "iDynTree::Wrench const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Wrench * >(argp1);
  result = ((iDynTree::Wrench const *)arg1)->operator -();
  _out = SWIG_NewPointerObj((new iDynTree::Wrench(static_cast< const iDynTree::Wrench& >(result))), SWIGTYPE_p_iDynTree__Wrench, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Wrench(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Wrench *arg1 = (iDynTree::Wrench *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Wrench",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Wrench, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Wrench" "', argument " "1"" of type '" "iDynTree::Wrench *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Wrench * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialMomentum__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SpatialMomentum *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialMomentum",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::SpatialMomentum *)new iDynTree::SpatialMomentum();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialMomentum, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialMomentum__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinMomentum *arg1 = 0 ;
  iDynTree::AngMomentum *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMomentum *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialMomentum",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialMomentum" "', argument " "1"" of type '" "iDynTree::LinMomentum const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialMomentum" "', argument " "1"" of type '" "iDynTree::LinMomentum const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinMomentum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpatialMomentum" "', argument " "2"" of type '" "iDynTree::AngMomentum const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialMomentum" "', argument " "2"" of type '" "iDynTree::AngMomentum const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::AngMomentum * >(argp2);
  result = (iDynTree::SpatialMomentum *)new iDynTree::SpatialMomentum((iDynTree::LinMomentum const &)*arg1,(iDynTree::AngMomentum const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialMomentum, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialMomentum__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialForceVector *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMomentum *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialMomentum",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialMomentum" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialMomentum" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp1);
  result = (iDynTree::SpatialMomentum *)new iDynTree::SpatialMomentum((iDynTree::SpatialForceVector const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialMomentum, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialMomentum__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMomentum *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMomentum *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialMomentum",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialMomentum,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialMomentum" "', argument " "1"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialMomentum" "', argument " "1"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp1);
  result = (iDynTree::SpatialMomentum *)new iDynTree::SpatialMomentum((iDynTree::SpatialMomentum const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialMomentum, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialMomentum(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_SpatialMomentum__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialMomentum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpatialMomentum__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialForceVector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpatialMomentum__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__GeomVector3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__GeomVector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SpatialMomentum__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_SpatialMomentum'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SpatialMomentum::SpatialMomentum()\n"
    "    iDynTree::SpatialMomentum::SpatialMomentum(iDynTree::LinMomentum const &,iDynTree::AngMomentum const &)\n"
    "    iDynTree::SpatialMomentum::SpatialMomentum(iDynTree::SpatialForceVector const &)\n"
    "    iDynTree::SpatialMomentum::SpatialMomentum(iDynTree::SpatialMomentum const &)\n");
  return 1;
}


int _wrap_SpatialMomentum_plus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMomentum *arg1 = (iDynTree::SpatialMomentum *) 0 ;
  iDynTree::SpatialMomentum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMomentum result;
  
  if (!SWIG_check_num_args("SpatialMomentum_plus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialMomentum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMomentum_plus" "', argument " "1"" of type '" "iDynTree::SpatialMomentum const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMomentum,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialMomentum_plus" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialMomentum_plus" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp2);
  result = ((iDynTree::SpatialMomentum const *)arg1)->operator +((iDynTree::SpatialMomentum const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMomentum(static_cast< const iDynTree::SpatialMomentum& >(result))), SWIGTYPE_p_iDynTree__SpatialMomentum, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMomentum_minus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMomentum *arg1 = (iDynTree::SpatialMomentum *) 0 ;
  iDynTree::SpatialMomentum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMomentum result;
  
  if (!SWIG_check_num_args("SpatialMomentum_minus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialMomentum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMomentum_minus" "', argument " "1"" of type '" "iDynTree::SpatialMomentum const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMomentum,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialMomentum_minus" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialMomentum_minus" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp2);
  result = ((iDynTree::SpatialMomentum const *)arg1)->operator -((iDynTree::SpatialMomentum const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMomentum(static_cast< const iDynTree::SpatialMomentum& >(result))), SWIGTYPE_p_iDynTree__SpatialMomentum, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialMomentum_uminus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMomentum *arg1 = (iDynTree::SpatialMomentum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMomentum result;
  
  if (!SWIG_check_num_args("SpatialMomentum_uminus",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialMomentum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialMomentum_uminus" "', argument " "1"" of type '" "iDynTree::SpatialMomentum const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp1);
  result = ((iDynTree::SpatialMomentum const *)arg1)->operator -();
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMomentum(static_cast< const iDynTree::SpatialMomentum& >(result))), SWIGTYPE_p_iDynTree__SpatialMomentum, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_SpatialMomentum(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMomentum *arg1 = (iDynTree::SpatialMomentum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SpatialMomentum",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialMomentum, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpatialMomentum" "', argument " "1"" of type '" "iDynTree::SpatialMomentum *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialAcc__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SpatialAcc *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialAcc",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::SpatialAcc *)new iDynTree::SpatialAcc();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialAcc, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialAcc__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinAcceleration *arg1 = 0 ;
  iDynTree::AngAcceleration *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialAcc",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialAcc" "', argument " "1"" of type '" "iDynTree::LinAcceleration const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialAcc" "', argument " "1"" of type '" "iDynTree::LinAcceleration const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinAcceleration * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpatialAcc" "', argument " "2"" of type '" "iDynTree::AngAcceleration const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialAcc" "', argument " "2"" of type '" "iDynTree::AngAcceleration const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::AngAcceleration * >(argp2);
  result = (iDynTree::SpatialAcc *)new iDynTree::SpatialAcc((iDynTree::LinAcceleration const &)*arg1,(iDynTree::AngAcceleration const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialAcc, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialAcc__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialMotionVector *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialAcc",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialAcc" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialAcc" "', argument " "1"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp1);
  result = (iDynTree::SpatialAcc *)new iDynTree::SpatialAcc((iDynTree::SpatialMotionVector const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialAcc, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialAcc__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialAcc *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialAcc",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialAcc" "', argument " "1"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialAcc" "', argument " "1"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialAcc * >(argp1);
  result = (iDynTree::SpatialAcc *)new iDynTree::SpatialAcc((iDynTree::SpatialAcc const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialAcc, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_SpatialAcc__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialAcc, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpatialAcc__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionVector, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpatialAcc__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__GeomVector3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__GeomVector3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SpatialAcc__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_SpatialAcc'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SpatialAcc::SpatialAcc()\n"
    "    iDynTree::SpatialAcc::SpatialAcc(iDynTree::LinAcceleration const &,iDynTree::AngAcceleration const &)\n"
    "    iDynTree::SpatialAcc::SpatialAcc(iDynTree::SpatialMotionVector const &)\n"
    "    iDynTree::SpatialAcc::SpatialAcc(iDynTree::SpatialAcc const &)\n");
  return 1;
}


int _wrap_SpatialAcc_plus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialAcc *arg1 = (iDynTree::SpatialAcc *) 0 ;
  iDynTree::SpatialAcc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc result;
  
  if (!SWIG_check_num_args("SpatialAcc_plus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialAcc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialAcc_plus" "', argument " "1"" of type '" "iDynTree::SpatialAcc const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialAcc * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialAcc_plus" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialAcc_plus" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialAcc * >(argp2);
  result = ((iDynTree::SpatialAcc const *)arg1)->operator +((iDynTree::SpatialAcc const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialAcc(static_cast< const iDynTree::SpatialAcc& >(result))), SWIGTYPE_p_iDynTree__SpatialAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialAcc_minus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialAcc *arg1 = (iDynTree::SpatialAcc *) 0 ;
  iDynTree::SpatialAcc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc result;
  
  if (!SWIG_check_num_args("SpatialAcc_minus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialAcc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialAcc_minus" "', argument " "1"" of type '" "iDynTree::SpatialAcc const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialAcc * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialAcc_minus" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialAcc_minus" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialAcc * >(argp2);
  result = ((iDynTree::SpatialAcc const *)arg1)->operator -((iDynTree::SpatialAcc const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialAcc(static_cast< const iDynTree::SpatialAcc& >(result))), SWIGTYPE_p_iDynTree__SpatialAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialAcc_uminus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialAcc *arg1 = (iDynTree::SpatialAcc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc result;
  
  if (!SWIG_check_num_args("SpatialAcc_uminus",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialAcc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialAcc_uminus" "', argument " "1"" of type '" "iDynTree::SpatialAcc const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialAcc * >(argp1);
  result = ((iDynTree::SpatialAcc const *)arg1)->operator -();
  _out = SWIG_NewPointerObj((new iDynTree::SpatialAcc(static_cast< const iDynTree::SpatialAcc& >(result))), SWIGTYPE_p_iDynTree__SpatialAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_SpatialAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialAcc *arg1 = (iDynTree::SpatialAcc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SpatialAcc",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialAcc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpatialAcc" "', argument " "1"" of type '" "iDynTree::SpatialAcc *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialAcc * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ClassicalAcc__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ClassicalAcc *result = 0 ;
  
  if (!SWIG_check_num_args("new_ClassicalAcc",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ClassicalAcc *)new iDynTree::ClassicalAcc();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ClassicalAcc, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ClassicalAcc__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::ClassicalAcc *result = 0 ;
  
  if (!SWIG_check_num_args("new_ClassicalAcc",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClassicalAcc" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClassicalAcc" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (iDynTree::ClassicalAcc *)new iDynTree::ClassicalAcc((double const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ClassicalAcc, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ClassicalAcc__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ClassicalAcc *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ClassicalAcc *result = 0 ;
  
  if (!SWIG_check_num_args("new_ClassicalAcc",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__ClassicalAcc,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ClassicalAcc" "', argument " "1"" of type '" "iDynTree::ClassicalAcc const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ClassicalAcc" "', argument " "1"" of type '" "iDynTree::ClassicalAcc const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ClassicalAcc * >(argp1);
  result = (iDynTree::ClassicalAcc *)new iDynTree::ClassicalAcc((iDynTree::ClassicalAcc const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ClassicalAcc, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ClassicalAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_ClassicalAcc__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ClassicalAcc, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ClassicalAcc__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_ClassicalAcc__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_ClassicalAcc'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ClassicalAcc::ClassicalAcc()\n"
    "    iDynTree::ClassicalAcc::ClassicalAcc(double const *,unsigned int const)\n"
    "    iDynTree::ClassicalAcc::ClassicalAcc(iDynTree::ClassicalAcc const &)\n");
  return 1;
}


int _wrap_ClassicalAcc_changeCoordFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ClassicalAcc *arg1 = (iDynTree::ClassicalAcc *) 0 ;
  iDynTree::RotationRaw *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::ClassicalAcc *result = 0 ;
  
  if (!SWIG_check_num_args("ClassicalAcc_changeCoordFrame",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ClassicalAcc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClassicalAcc_changeCoordFrame" "', argument " "1"" of type '" "iDynTree::ClassicalAcc *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ClassicalAcc * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__RotationRaw,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ClassicalAcc_changeCoordFrame" "', argument " "2"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClassicalAcc_changeCoordFrame" "', argument " "2"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::RotationRaw * >(argp2);
  result = (iDynTree::ClassicalAcc *) &(arg1)->changeCoordFrame((iDynTree::RotationRaw const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ClassicalAcc, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ClassicalAcc_Zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ClassicalAcc result;
  
  if (!SWIG_check_num_args("ClassicalAcc_Zero",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = iDynTree::ClassicalAcc::Zero();
  _out = SWIG_NewPointerObj((new iDynTree::ClassicalAcc(static_cast< const iDynTree::ClassicalAcc& >(result))), SWIGTYPE_p_iDynTree__ClassicalAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ClassicalAcc_fromSpatial(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ClassicalAcc *arg1 = (iDynTree::ClassicalAcc *) 0 ;
  iDynTree::SpatialAcc *arg2 = 0 ;
  iDynTree::Twist *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ClassicalAcc_fromSpatial",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ClassicalAcc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClassicalAcc_fromSpatial" "', argument " "1"" of type '" "iDynTree::ClassicalAcc *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ClassicalAcc * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ClassicalAcc_fromSpatial" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClassicalAcc_fromSpatial" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialAcc * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ClassicalAcc_fromSpatial" "', argument " "3"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClassicalAcc_fromSpatial" "', argument " "3"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Twist * >(argp3);
  (arg1)->fromSpatial((iDynTree::SpatialAcc const &)*arg2,(iDynTree::Twist const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ClassicalAcc_toSpatial(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ClassicalAcc *arg1 = (iDynTree::ClassicalAcc *) 0 ;
  iDynTree::SpatialAcc *arg2 = 0 ;
  iDynTree::Twist *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ClassicalAcc_toSpatial",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ClassicalAcc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClassicalAcc_toSpatial" "', argument " "1"" of type '" "iDynTree::ClassicalAcc const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ClassicalAcc * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ClassicalAcc_toSpatial" "', argument " "2"" of type '" "iDynTree::SpatialAcc &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClassicalAcc_toSpatial" "', argument " "2"" of type '" "iDynTree::SpatialAcc &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialAcc * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ClassicalAcc_toSpatial" "', argument " "3"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ClassicalAcc_toSpatial" "', argument " "3"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Twist * >(argp3);
  ((iDynTree::ClassicalAcc const *)arg1)->toSpatial(*arg2,(iDynTree::Twist const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ClassicalAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ClassicalAcc *arg1 = (iDynTree::ClassicalAcc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ClassicalAcc",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ClassicalAcc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ClassicalAcc" "', argument " "1"" of type '" "iDynTree::ClassicalAcc *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ClassicalAcc * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Direction__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Direction *result = 0 ;
  
  if (!SWIG_check_num_args("new_Direction",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Direction *)new iDynTree::Direction();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Direction, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Direction__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::Direction *result = 0 ;
  
  if (!SWIG_check_num_args("new_Direction",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Direction" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Direction" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Direction" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (iDynTree::Direction *)new iDynTree::Direction(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Direction, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Direction__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Direction *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Direction *result = 0 ;
  
  if (!SWIG_check_num_args("new_Direction",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Direction" "', argument " "1"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Direction" "', argument " "1"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Direction * >(argp1);
  result = (iDynTree::Direction *)new iDynTree::Direction((iDynTree::Direction const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Direction, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Direction__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Direction *result = 0 ;
  
  if (!SWIG_check_num_args("new_Direction",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Direction" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Direction" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (iDynTree::Direction *)new iDynTree::Direction((double const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Direction, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Direction(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Direction__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Direction__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Direction__SWIG_3(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Direction__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Direction'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Direction::Direction()\n"
    "    iDynTree::Direction::Direction(double,double,double)\n"
    "    iDynTree::Direction::Direction(iDynTree::Direction const &)\n"
    "    iDynTree::Direction::Direction(double const *,unsigned int const)\n");
  return 1;
}


int _wrap_Direction_Normalize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Direction *arg1 = (iDynTree::Direction *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Direction_Normalize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Direction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Direction_Normalize" "', argument " "1"" of type '" "iDynTree::Direction *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Direction * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Direction_Normalize" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->Normalize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Direction_Normalize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Direction *arg1 = (iDynTree::Direction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Direction_Normalize",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Direction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Direction_Normalize" "', argument " "1"" of type '" "iDynTree::Direction *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Direction * >(argp1);
  (arg1)->Normalize();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Direction_Normalize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Direction_Normalize__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Direction_Normalize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Direction_Normalize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Direction::Normalize(double)\n"
    "    iDynTree::Direction::Normalize()\n");
  return 1;
}


int _wrap_Direction_isParallel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Direction *arg1 = (iDynTree::Direction *) 0 ;
  iDynTree::Direction *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Direction_isParallel",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Direction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Direction_isParallel" "', argument " "1"" of type '" "iDynTree::Direction const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Direction * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Direction_isParallel" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Direction_isParallel" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Direction * >(argp2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Direction_isParallel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)((iDynTree::Direction const *)arg1)->isParallel((iDynTree::Direction const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Direction_isPerpendicular(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Direction *arg1 = (iDynTree::Direction *) 0 ;
  iDynTree::Direction *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Direction_isPerpendicular",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Direction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Direction_isPerpendicular" "', argument " "1"" of type '" "iDynTree::Direction const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Direction * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Direction_isPerpendicular" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Direction_isPerpendicular" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Direction * >(argp2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Direction_isPerpendicular" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)((iDynTree::Direction const *)arg1)->isPerpendicular((iDynTree::Direction const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Direction_reverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Direction *arg1 = (iDynTree::Direction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Direction result;
  
  if (!SWIG_check_num_args("Direction_reverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Direction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Direction_reverse" "', argument " "1"" of type '" "iDynTree::Direction const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Direction * >(argp1);
  result = ((iDynTree::Direction const *)arg1)->reverse();
  _out = SWIG_NewPointerObj((new iDynTree::Direction(static_cast< const iDynTree::Direction& >(result))), SWIGTYPE_p_iDynTree__Direction, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Direction_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Direction *arg1 = (iDynTree::Direction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Direction_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Direction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Direction_toString" "', argument " "1"" of type '" "iDynTree::Direction const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Direction * >(argp1);
  result = ((iDynTree::Direction const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Direction_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Direction *arg1 = (iDynTree::Direction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Direction_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Direction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Direction_display" "', argument " "1"" of type '" "iDynTree::Direction const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Direction * >(argp1);
  result = ((iDynTree::Direction const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Direction_Default(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Direction result;
  
  if (!SWIG_check_num_args("Direction_Default",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = iDynTree::Direction::Default();
  _out = SWIG_NewPointerObj((new iDynTree::Direction(static_cast< const iDynTree::Direction& >(result))), SWIGTYPE_p_iDynTree__Direction, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Direction(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Direction *arg1 = (iDynTree::Direction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Direction",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Direction, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Direction" "', argument " "1"" of type '" "iDynTree::Direction *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Direction * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Axis__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Axis *result = 0 ;
  
  if (!SWIG_check_num_args("new_Axis",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Axis *)new iDynTree::Axis();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Axis, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Axis__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Direction *arg1 = 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Axis *result = 0 ;
  
  if (!SWIG_check_num_args("new_Axis",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Axis" "', argument " "1"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Axis" "', argument " "1"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Direction * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Axis" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Axis" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = (iDynTree::Axis *)new iDynTree::Axis((iDynTree::Direction const &)*arg1,(iDynTree::Position const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Axis, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Axis__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Axis *result = 0 ;
  
  if (!SWIG_check_num_args("new_Axis",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Axis,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Axis" "', argument " "1"" of type '" "iDynTree::Axis const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Axis" "', argument " "1"" of type '" "iDynTree::Axis const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  result = (iDynTree::Axis *)new iDynTree::Axis((iDynTree::Axis const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Axis, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Axis(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Axis__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Axis, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Axis__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Axis__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Axis'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Axis::Axis()\n"
    "    iDynTree::Axis::Axis(iDynTree::Direction const &,iDynTree::Position const &)\n"
    "    iDynTree::Axis::Axis(iDynTree::Axis const &)\n");
  return 1;
}


int _wrap_Axis_getDirection(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Direction *result = 0 ;
  
  if (!SWIG_check_num_args("Axis_getDirection",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_getDirection" "', argument " "1"" of type '" "iDynTree::Axis const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  result = (iDynTree::Direction *) &((iDynTree::Axis const *)arg1)->getDirection();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Direction, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_getOrigin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("Axis_getOrigin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_getOrigin" "', argument " "1"" of type '" "iDynTree::Axis const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  result = (iDynTree::Position *) &((iDynTree::Axis const *)arg1)->getOrigin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_setDirection(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  iDynTree::Direction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Axis_setDirection",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_setDirection" "', argument " "1"" of type '" "iDynTree::Axis *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Axis_setDirection" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Axis_setDirection" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Direction * >(argp2);
  (arg1)->setDirection((iDynTree::Direction const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_setOrigin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Axis_setOrigin",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_setOrigin" "', argument " "1"" of type '" "iDynTree::Axis *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Axis_setOrigin" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Axis_setOrigin" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  (arg1)->setOrigin((iDynTree::Position const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_getRotationTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("Axis_getRotationTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_getRotationTransform" "', argument " "1"" of type '" "iDynTree::Axis const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Axis_getRotationTransform" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((iDynTree::Axis const *)arg1)->getRotationTransform(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_getRotationTransformDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::TransformDerivative result;
  
  if (!SWIG_check_num_args("Axis_getRotationTransformDerivative",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_getRotationTransformDerivative" "', argument " "1"" of type '" "iDynTree::Axis const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Axis_getRotationTransformDerivative" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((iDynTree::Axis const *)arg1)->getRotationTransformDerivative(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::TransformDerivative(static_cast< const iDynTree::TransformDerivative& >(result))), SWIGTYPE_p_iDynTree__TransformDerivative, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_getRotationTwist(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("Axis_getRotationTwist",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_getRotationTwist" "', argument " "1"" of type '" "iDynTree::Axis const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Axis_getRotationTwist" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((iDynTree::Axis const *)arg1)->getRotationTwist(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_getRotationSpatialAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc result;
  
  if (!SWIG_check_num_args("Axis_getRotationSpatialAcc",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_getRotationSpatialAcc" "', argument " "1"" of type '" "iDynTree::Axis const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Axis_getRotationSpatialAcc" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((iDynTree::Axis const *)arg1)->getRotationSpatialAcc(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialAcc(static_cast< const iDynTree::SpatialAcc& >(result))), SWIGTYPE_p_iDynTree__SpatialAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_getTranslationTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("Axis_getTranslationTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_getTranslationTransform" "', argument " "1"" of type '" "iDynTree::Axis const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Axis_getTranslationTransform" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((iDynTree::Axis const *)arg1)->getTranslationTransform(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_getTranslationTransformDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::TransformDerivative result;
  
  if (!SWIG_check_num_args("Axis_getTranslationTransformDerivative",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_getTranslationTransformDerivative" "', argument " "1"" of type '" "iDynTree::Axis const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Axis_getTranslationTransformDerivative" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((iDynTree::Axis const *)arg1)->getTranslationTransformDerivative(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::TransformDerivative(static_cast< const iDynTree::TransformDerivative& >(result))), SWIGTYPE_p_iDynTree__TransformDerivative, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_getTranslationTwist(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("Axis_getTranslationTwist",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_getTranslationTwist" "', argument " "1"" of type '" "iDynTree::Axis const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Axis_getTranslationTwist" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((iDynTree::Axis const *)arg1)->getTranslationTwist(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_getTranslationSpatialAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc result;
  
  if (!SWIG_check_num_args("Axis_getTranslationSpatialAcc",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_getTranslationSpatialAcc" "', argument " "1"" of type '" "iDynTree::Axis const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Axis_getTranslationSpatialAcc" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = ((iDynTree::Axis const *)arg1)->getTranslationSpatialAcc(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialAcc(static_cast< const iDynTree::SpatialAcc& >(result))), SWIGTYPE_p_iDynTree__SpatialAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_isParallel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  iDynTree::Axis *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Axis_isParallel",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_isParallel" "', argument " "1"" of type '" "iDynTree::Axis const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Axis,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Axis_isParallel" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Axis_isParallel" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Axis * >(argp2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Axis_isParallel" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)((iDynTree::Axis const *)arg1)->isParallel((iDynTree::Axis const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_reverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Axis result;
  
  if (!SWIG_check_num_args("Axis_reverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_reverse" "', argument " "1"" of type '" "iDynTree::Axis const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  result = ((iDynTree::Axis const *)arg1)->reverse();
  _out = SWIG_NewPointerObj((new iDynTree::Axis(static_cast< const iDynTree::Axis& >(result))), SWIGTYPE_p_iDynTree__Axis, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Axis_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_toString" "', argument " "1"" of type '" "iDynTree::Axis const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  result = ((iDynTree::Axis const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Axis_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Axis_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Axis_display" "', argument " "1"" of type '" "iDynTree::Axis const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  result = ((iDynTree::Axis const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Axis(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Axis *arg1 = (iDynTree::Axis *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Axis",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Axis, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Axis" "', argument " "1"" of type '" "iDynTree::Axis *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Axis * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RotationalInertiaRaw__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::RotationalInertiaRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_RotationalInertiaRaw",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::RotationalInertiaRaw *)new iDynTree::RotationalInertiaRaw();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RotationalInertiaRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RotationalInertiaRaw__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::RotationalInertiaRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_RotationalInertiaRaw",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RotationalInertiaRaw" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RotationalInertiaRaw" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RotationalInertiaRaw" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (iDynTree::RotationalInertiaRaw *)new iDynTree::RotationalInertiaRaw((double const *)arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RotationalInertiaRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RotationalInertiaRaw__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RotationalInertiaRaw *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::RotationalInertiaRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_RotationalInertiaRaw",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__RotationalInertiaRaw,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RotationalInertiaRaw" "', argument " "1"" of type '" "iDynTree::RotationalInertiaRaw const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RotationalInertiaRaw" "', argument " "1"" of type '" "iDynTree::RotationalInertiaRaw const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RotationalInertiaRaw * >(argp1);
  result = (iDynTree::RotationalInertiaRaw *)new iDynTree::RotationalInertiaRaw((iDynTree::RotationalInertiaRaw const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RotationalInertiaRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RotationalInertiaRaw(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_RotationalInertiaRaw__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__RotationalInertiaRaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RotationalInertiaRaw__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_RotationalInertiaRaw__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_RotationalInertiaRaw'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::RotationalInertiaRaw::RotationalInertiaRaw()\n"
    "    iDynTree::RotationalInertiaRaw::RotationalInertiaRaw(double const *,unsigned int const,unsigned int const)\n"
    "    iDynTree::RotationalInertiaRaw::RotationalInertiaRaw(iDynTree::RotationalInertiaRaw const &)\n");
  return 1;
}


int _wrap_RotationalInertiaRaw_Zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::RotationalInertiaRaw result;
  
  if (!SWIG_check_num_args("RotationalInertiaRaw_Zero",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = iDynTree::RotationalInertiaRaw::Zero();
  _out = SWIG_NewPointerObj((new iDynTree::RotationalInertiaRaw(static_cast< const iDynTree::RotationalInertiaRaw& >(result))), SWIGTYPE_p_iDynTree__RotationalInertiaRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_RotationalInertiaRaw(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RotationalInertiaRaw *arg1 = (iDynTree::RotationalInertiaRaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_RotationalInertiaRaw",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RotationalInertiaRaw, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RotationalInertiaRaw" "', argument " "1"" of type '" "iDynTree::RotationalInertiaRaw *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RotationalInertiaRaw * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialInertiaRaw__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SpatialInertiaRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialInertiaRaw",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::SpatialInertiaRaw *)new iDynTree::SpatialInertiaRaw();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialInertiaRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialInertiaRaw__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  iDynTree::PositionRaw *arg2 = 0 ;
  iDynTree::RotationalInertiaRaw *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertiaRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialInertiaRaw",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpatialInertiaRaw" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__PositionRaw,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpatialInertiaRaw" "', argument " "2"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialInertiaRaw" "', argument " "2"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::PositionRaw * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__RotationalInertiaRaw,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SpatialInertiaRaw" "', argument " "3"" of type '" "iDynTree::RotationalInertiaRaw const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialInertiaRaw" "', argument " "3"" of type '" "iDynTree::RotationalInertiaRaw const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::RotationalInertiaRaw * >(argp3);
  result = (iDynTree::SpatialInertiaRaw *)new iDynTree::SpatialInertiaRaw(arg1,(iDynTree::PositionRaw const &)*arg2,(iDynTree::RotationalInertiaRaw const &)*arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialInertiaRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialInertiaRaw__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertiaRaw *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertiaRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialInertiaRaw",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialInertiaRaw,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialInertiaRaw" "', argument " "1"" of type '" "iDynTree::SpatialInertiaRaw const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialInertiaRaw" "', argument " "1"" of type '" "iDynTree::SpatialInertiaRaw const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertiaRaw * >(argp1);
  result = (iDynTree::SpatialInertiaRaw *)new iDynTree::SpatialInertiaRaw((iDynTree::SpatialInertiaRaw const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialInertiaRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialInertiaRaw(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_SpatialInertiaRaw__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialInertiaRaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpatialInertiaRaw__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__PositionRaw, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__RotationalInertiaRaw, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SpatialInertiaRaw__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_SpatialInertiaRaw'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SpatialInertiaRaw::SpatialInertiaRaw()\n"
    "    iDynTree::SpatialInertiaRaw::SpatialInertiaRaw(double const,iDynTree::PositionRaw const &,iDynTree::RotationalInertiaRaw const &)\n"
    "    iDynTree::SpatialInertiaRaw::SpatialInertiaRaw(iDynTree::SpatialInertiaRaw const &)\n");
  return 1;
}


int _wrap_SpatialInertiaRaw_fromRotationalInertiaWrtCenterOfMass(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertiaRaw *arg1 = (iDynTree::SpatialInertiaRaw *) 0 ;
  double arg2 ;
  iDynTree::PositionRaw *arg3 = 0 ;
  iDynTree::RotationalInertiaRaw *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SpatialInertiaRaw_fromRotationalInertiaWrtCenterOfMass",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertiaRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertiaRaw_fromRotationalInertiaWrtCenterOfMass" "', argument " "1"" of type '" "iDynTree::SpatialInertiaRaw *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertiaRaw * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SpatialInertiaRaw_fromRotationalInertiaWrtCenterOfMass" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__PositionRaw,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpatialInertiaRaw_fromRotationalInertiaWrtCenterOfMass" "', argument " "3"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertiaRaw_fromRotationalInertiaWrtCenterOfMass" "', argument " "3"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::PositionRaw * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__RotationalInertiaRaw,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SpatialInertiaRaw_fromRotationalInertiaWrtCenterOfMass" "', argument " "4"" of type '" "iDynTree::RotationalInertiaRaw const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertiaRaw_fromRotationalInertiaWrtCenterOfMass" "', argument " "4"" of type '" "iDynTree::RotationalInertiaRaw const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::RotationalInertiaRaw * >(argp4);
  (arg1)->fromRotationalInertiaWrtCenterOfMass(arg2,(iDynTree::PositionRaw const &)*arg3,(iDynTree::RotationalInertiaRaw const &)*arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertiaRaw_getMass(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertiaRaw *arg1 = (iDynTree::SpatialInertiaRaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("SpatialInertiaRaw_getMass",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertiaRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertiaRaw_getMass" "', argument " "1"" of type '" "iDynTree::SpatialInertiaRaw const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertiaRaw * >(argp1);
  result = (double)((iDynTree::SpatialInertiaRaw const *)arg1)->getMass();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertiaRaw_getCenterOfMass(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertiaRaw *arg1 = (iDynTree::SpatialInertiaRaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::PositionRaw result;
  
  if (!SWIG_check_num_args("SpatialInertiaRaw_getCenterOfMass",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertiaRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertiaRaw_getCenterOfMass" "', argument " "1"" of type '" "iDynTree::SpatialInertiaRaw const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertiaRaw * >(argp1);
  result = ((iDynTree::SpatialInertiaRaw const *)arg1)->getCenterOfMass();
  _out = SWIG_NewPointerObj((new iDynTree::PositionRaw(static_cast< const iDynTree::PositionRaw& >(result))), SWIGTYPE_p_iDynTree__PositionRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertiaRaw_getRotationalInertiaWrtFrameOrigin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertiaRaw *arg1 = (iDynTree::SpatialInertiaRaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::RotationalInertiaRaw *result = 0 ;
  
  if (!SWIG_check_num_args("SpatialInertiaRaw_getRotationalInertiaWrtFrameOrigin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertiaRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertiaRaw_getRotationalInertiaWrtFrameOrigin" "', argument " "1"" of type '" "iDynTree::SpatialInertiaRaw const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertiaRaw * >(argp1);
  result = (iDynTree::RotationalInertiaRaw *) &((iDynTree::SpatialInertiaRaw const *)arg1)->getRotationalInertiaWrtFrameOrigin();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RotationalInertiaRaw, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertiaRaw_getRotationalInertiaWrtCenterOfMass(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertiaRaw *arg1 = (iDynTree::SpatialInertiaRaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::RotationalInertiaRaw result;
  
  if (!SWIG_check_num_args("SpatialInertiaRaw_getRotationalInertiaWrtCenterOfMass",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertiaRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertiaRaw_getRotationalInertiaWrtCenterOfMass" "', argument " "1"" of type '" "iDynTree::SpatialInertiaRaw const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertiaRaw * >(argp1);
  result = ((iDynTree::SpatialInertiaRaw const *)arg1)->getRotationalInertiaWrtCenterOfMass();
  _out = SWIG_NewPointerObj((new iDynTree::RotationalInertiaRaw(static_cast< const iDynTree::RotationalInertiaRaw& >(result))), SWIGTYPE_p_iDynTree__RotationalInertiaRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertiaRaw_combine(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertiaRaw *arg1 = 0 ;
  iDynTree::SpatialInertiaRaw *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertiaRaw result;
  
  if (!SWIG_check_num_args("SpatialInertiaRaw_combine",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialInertiaRaw,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertiaRaw_combine" "', argument " "1"" of type '" "iDynTree::SpatialInertiaRaw const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertiaRaw_combine" "', argument " "1"" of type '" "iDynTree::SpatialInertiaRaw const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertiaRaw * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialInertiaRaw,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialInertiaRaw_combine" "', argument " "2"" of type '" "iDynTree::SpatialInertiaRaw const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertiaRaw_combine" "', argument " "2"" of type '" "iDynTree::SpatialInertiaRaw const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialInertiaRaw * >(argp2);
  result = iDynTree::SpatialInertiaRaw::combine((iDynTree::SpatialInertiaRaw const &)*arg1,(iDynTree::SpatialInertiaRaw const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialInertiaRaw(static_cast< const iDynTree::SpatialInertiaRaw& >(result))), SWIGTYPE_p_iDynTree__SpatialInertiaRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertiaRaw_multiply(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertiaRaw *arg1 = (iDynTree::SpatialInertiaRaw *) 0 ;
  iDynTree::SpatialMotionVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("SpatialInertiaRaw_multiply",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertiaRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertiaRaw_multiply" "', argument " "1"" of type '" "iDynTree::SpatialInertiaRaw const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertiaRaw * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialInertiaRaw_multiply" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertiaRaw_multiply" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp2);
  result = ((iDynTree::SpatialInertiaRaw const *)arg1)->multiply((iDynTree::SpatialMotionVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertiaRaw_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertiaRaw *arg1 = (iDynTree::SpatialInertiaRaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SpatialInertiaRaw_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertiaRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertiaRaw_zero" "', argument " "1"" of type '" "iDynTree::SpatialInertiaRaw *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertiaRaw * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_SpatialInertiaRaw(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertiaRaw *arg1 = (iDynTree::SpatialInertiaRaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SpatialInertiaRaw",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertiaRaw, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpatialInertiaRaw" "', argument " "1"" of type '" "iDynTree::SpatialInertiaRaw *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertiaRaw * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialInertia__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SpatialInertia *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialInertia",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::SpatialInertia *)new iDynTree::SpatialInertia();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialInertia, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialInertia__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  iDynTree::PositionRaw *arg2 = 0 ;
  iDynTree::RotationalInertiaRaw *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertia *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialInertia",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SpatialInertia" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__PositionRaw,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SpatialInertia" "', argument " "2"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialInertia" "', argument " "2"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::PositionRaw * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__RotationalInertiaRaw,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_SpatialInertia" "', argument " "3"" of type '" "iDynTree::RotationalInertiaRaw const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialInertia" "', argument " "3"" of type '" "iDynTree::RotationalInertiaRaw const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::RotationalInertiaRaw * >(argp3);
  result = (iDynTree::SpatialInertia *)new iDynTree::SpatialInertia(arg1,(iDynTree::PositionRaw const &)*arg2,(iDynTree::RotationalInertiaRaw const &)*arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialInertia, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialInertia__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertiaRaw *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertia *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialInertia",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialInertiaRaw,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialInertia" "', argument " "1"" of type '" "iDynTree::SpatialInertiaRaw const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialInertia" "', argument " "1"" of type '" "iDynTree::SpatialInertiaRaw const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertiaRaw * >(argp1);
  result = (iDynTree::SpatialInertia *)new iDynTree::SpatialInertia((iDynTree::SpatialInertiaRaw const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialInertia, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialInertia__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertia *result = 0 ;
  
  if (!SWIG_check_num_args("new_SpatialInertia",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialInertia,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SpatialInertia" "', argument " "1"" of type '" "iDynTree::SpatialInertia const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SpatialInertia" "', argument " "1"" of type '" "iDynTree::SpatialInertia const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  result = (iDynTree::SpatialInertia *)new iDynTree::SpatialInertia((iDynTree::SpatialInertia const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialInertia, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SpatialInertia(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_SpatialInertia__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialInertia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpatialInertia__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialInertiaRaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SpatialInertia__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__PositionRaw, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__RotationalInertiaRaw, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_SpatialInertia__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_SpatialInertia'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SpatialInertia::SpatialInertia()\n"
    "    iDynTree::SpatialInertia::SpatialInertia(double const,iDynTree::PositionRaw const &,iDynTree::RotationalInertiaRaw const &)\n"
    "    iDynTree::SpatialInertia::SpatialInertia(iDynTree::SpatialInertiaRaw const &)\n"
    "    iDynTree::SpatialInertia::SpatialInertia(iDynTree::SpatialInertia const &)\n");
  return 1;
}


int _wrap_SpatialInertia_combine(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = 0 ;
  iDynTree::SpatialInertia *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertia result;
  
  if (!SWIG_check_num_args("SpatialInertia_combine",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialInertia,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_combine" "', argument " "1"" of type '" "iDynTree::SpatialInertia const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_combine" "', argument " "1"" of type '" "iDynTree::SpatialInertia const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialInertia,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialInertia_combine" "', argument " "2"" of type '" "iDynTree::SpatialInertia const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_combine" "', argument " "2"" of type '" "iDynTree::SpatialInertia const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialInertia * >(argp2);
  result = iDynTree::SpatialInertia::combine((iDynTree::SpatialInertia const &)*arg1,(iDynTree::SpatialInertia const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialInertia(static_cast< const iDynTree::SpatialInertia& >(result))), SWIGTYPE_p_iDynTree__SpatialInertia, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_asMatrix(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = (iDynTree::SpatialInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix6x6 result;
  
  if (!SWIG_check_num_args("SpatialInertia_asMatrix",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_asMatrix" "', argument " "1"" of type '" "iDynTree::SpatialInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  result = ((iDynTree::SpatialInertia const *)arg1)->asMatrix();
  _out = SWIG_NewPointerObj((new iDynTree::Matrix6x6(static_cast< const iDynTree::Matrix6x6& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_applyInverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = (iDynTree::SpatialInertia *) 0 ;
  iDynTree::SpatialMomentum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("SpatialInertia_applyInverse",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_applyInverse" "', argument " "1"" of type '" "iDynTree::SpatialInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMomentum,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialInertia_applyInverse" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_applyInverse" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp2);
  result = ((iDynTree::SpatialInertia const *)arg1)->applyInverse((iDynTree::SpatialMomentum const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_getInverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = (iDynTree::SpatialInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix6x6 result;
  
  if (!SWIG_check_num_args("SpatialInertia_getInverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_getInverse" "', argument " "1"" of type '" "iDynTree::SpatialInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  result = ((iDynTree::SpatialInertia const *)arg1)->getInverse();
  _out = SWIG_NewPointerObj((new iDynTree::Matrix6x6(static_cast< const iDynTree::Matrix6x6& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_plus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = (iDynTree::SpatialInertia *) 0 ;
  iDynTree::SpatialInertia *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertia result;
  
  if (!SWIG_check_num_args("SpatialInertia_plus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_plus" "', argument " "1"" of type '" "iDynTree::SpatialInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialInertia,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialInertia_plus" "', argument " "2"" of type '" "iDynTree::SpatialInertia const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_plus" "', argument " "2"" of type '" "iDynTree::SpatialInertia const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialInertia * >(argp2);
  result = ((iDynTree::SpatialInertia const *)arg1)->operator +((iDynTree::SpatialInertia const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialInertia(static_cast< const iDynTree::SpatialInertia& >(result))), SWIGTYPE_p_iDynTree__SpatialInertia, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_mtimes__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = (iDynTree::SpatialInertia *) 0 ;
  iDynTree::SpatialMotionVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("SpatialInertia_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_mtimes" "', argument " "1"" of type '" "iDynTree::SpatialInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialInertia_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp2);
  result = ((iDynTree::SpatialInertia const *)arg1)->operator *((iDynTree::SpatialMotionVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_mtimes__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = (iDynTree::SpatialInertia *) 0 ;
  iDynTree::Twist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMomentum result;
  
  if (!SWIG_check_num_args("SpatialInertia_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_mtimes" "', argument " "1"" of type '" "iDynTree::SpatialInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialInertia_mtimes" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_mtimes" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Twist * >(argp2);
  result = ((iDynTree::SpatialInertia const *)arg1)->operator *((iDynTree::Twist const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMomentum(static_cast< const iDynTree::SpatialMomentum& >(result))), SWIGTYPE_p_iDynTree__SpatialMomentum, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_mtimes__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = (iDynTree::SpatialInertia *) 0 ;
  iDynTree::SpatialAcc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Wrench result;
  
  if (!SWIG_check_num_args("SpatialInertia_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_mtimes" "', argument " "1"" of type '" "iDynTree::SpatialInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialInertia_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialAcc * >(argp2);
  result = ((iDynTree::SpatialInertia const *)arg1)->operator *((iDynTree::SpatialAcc const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Wrench(static_cast< const iDynTree::Wrench& >(result))), SWIGTYPE_p_iDynTree__Wrench, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_mtimes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialInertia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Twist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpatialInertia_mtimes__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialInertia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialAcc, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpatialInertia_mtimes__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialInertia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionVector, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SpatialInertia_mtimes__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SpatialInertia_mtimes'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SpatialInertia::operator *(iDynTree::SpatialMotionVector const &) const\n"
    "    iDynTree::SpatialInertia::operator *(iDynTree::Twist const &) const\n"
    "    iDynTree::SpatialInertia::operator *(iDynTree::SpatialAcc const &) const\n");
  return 1;
}


int _wrap_SpatialInertia_biasWrench(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = (iDynTree::SpatialInertia *) 0 ;
  iDynTree::Twist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Wrench result;
  
  if (!SWIG_check_num_args("SpatialInertia_biasWrench",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_biasWrench" "', argument " "1"" of type '" "iDynTree::SpatialInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialInertia_biasWrench" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_biasWrench" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Twist * >(argp2);
  result = ((iDynTree::SpatialInertia const *)arg1)->biasWrench((iDynTree::Twist const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Wrench(static_cast< const iDynTree::Wrench& >(result))), SWIGTYPE_p_iDynTree__Wrench, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_biasWrenchDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = (iDynTree::SpatialInertia *) 0 ;
  iDynTree::Twist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Matrix6x6 result;
  
  if (!SWIG_check_num_args("SpatialInertia_biasWrenchDerivative",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_biasWrenchDerivative" "', argument " "1"" of type '" "iDynTree::SpatialInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialInertia_biasWrenchDerivative" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_biasWrenchDerivative" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Twist * >(argp2);
  result = ((iDynTree::SpatialInertia const *)arg1)->biasWrenchDerivative((iDynTree::Twist const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Matrix6x6(static_cast< const iDynTree::Matrix6x6& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_Zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SpatialInertia result;
  
  if (!SWIG_check_num_args("SpatialInertia_Zero",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = iDynTree::SpatialInertia::Zero();
  _out = SWIG_NewPointerObj((new iDynTree::SpatialInertia(static_cast< const iDynTree::SpatialInertia& >(result))), SWIGTYPE_p_iDynTree__SpatialInertia, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_asVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = (iDynTree::SpatialInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Vector10 result;
  
  if (!SWIG_check_num_args("SpatialInertia_asVector",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_asVector" "', argument " "1"" of type '" "iDynTree::SpatialInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  result = ((iDynTree::SpatialInertia const *)arg1)->asVector();
  _out = SWIG_NewPointerObj((new iDynTree::Vector10(static_cast< const iDynTree::Vector10& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_fromVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = (iDynTree::SpatialInertia *) 0 ;
  iDynTree::Vector10 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SpatialInertia_fromVector",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_fromVector" "', argument " "1"" of type '" "iDynTree::SpatialInertia *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialInertia_fromVector" "', argument " "2"" of type '" "iDynTree::Vector10 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_fromVector" "', argument " "2"" of type '" "iDynTree::Vector10 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector10 * >(argp2);
  (arg1)->fromVector((iDynTree::Vector10 const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_isPhysicallyConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = (iDynTree::SpatialInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SpatialInertia_isPhysicallyConsistent",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_isPhysicallyConsistent" "', argument " "1"" of type '" "iDynTree::SpatialInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  result = (bool)((iDynTree::SpatialInertia const *)arg1)->isPhysicallyConsistent();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_momentumRegressor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Twist *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix6x10 result;
  
  if (!SWIG_check_num_args("SpatialInertia_momentumRegressor",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_momentumRegressor" "', argument " "1"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_momentumRegressor" "', argument " "1"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Twist * >(argp1);
  result = iDynTree::SpatialInertia::momentumRegressor((iDynTree::Twist const &)*arg1);
  _out = SWIG_NewPointerObj((new iDynTree::Matrix6x10(static_cast< const iDynTree::Matrix6x10& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_momentumDerivativeRegressor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Twist *arg1 = 0 ;
  iDynTree::SpatialAcc *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Matrix6x10 result;
  
  if (!SWIG_check_num_args("SpatialInertia_momentumDerivativeRegressor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_momentumDerivativeRegressor" "', argument " "1"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_momentumDerivativeRegressor" "', argument " "1"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Twist * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialInertia_momentumDerivativeRegressor" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_momentumDerivativeRegressor" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialAcc * >(argp2);
  result = iDynTree::SpatialInertia::momentumDerivativeRegressor((iDynTree::Twist const &)*arg1,(iDynTree::SpatialAcc const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Matrix6x10(static_cast< const iDynTree::Matrix6x10& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SpatialInertia_momentumDerivativeSlotineLiRegressor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Twist *arg1 = 0 ;
  iDynTree::Twist *arg2 = 0 ;
  iDynTree::SpatialAcc *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::Matrix6x10 result;
  
  if (!SWIG_check_num_args("SpatialInertia_momentumDerivativeSlotineLiRegressor",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpatialInertia_momentumDerivativeSlotineLiRegressor" "', argument " "1"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_momentumDerivativeSlotineLiRegressor" "', argument " "1"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Twist * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SpatialInertia_momentumDerivativeSlotineLiRegressor" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_momentumDerivativeSlotineLiRegressor" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Twist * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SpatialInertia_momentumDerivativeSlotineLiRegressor" "', argument " "3"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SpatialInertia_momentumDerivativeSlotineLiRegressor" "', argument " "3"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::SpatialAcc * >(argp3);
  result = iDynTree::SpatialInertia::momentumDerivativeSlotineLiRegressor((iDynTree::Twist const &)*arg1,(iDynTree::Twist const &)*arg2,(iDynTree::SpatialAcc const &)*arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Matrix6x10(static_cast< const iDynTree::Matrix6x10& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_10_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_SpatialInertia(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = (iDynTree::SpatialInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SpatialInertia",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpatialInertia, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SpatialInertia" "', argument " "1"" of type '" "iDynTree::SpatialInertia *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ArticulatedBodyInertia__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ArticulatedBodyInertia *result = 0 ;
  
  if (!SWIG_check_num_args("new_ArticulatedBodyInertia",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ArticulatedBodyInertia *)new iDynTree::ArticulatedBodyInertia();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ArticulatedBodyInertia__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::ArticulatedBodyInertia *result = 0 ;
  
  if (!SWIG_check_num_args("new_ArticulatedBodyInertia",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArticulatedBodyInertia" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ArticulatedBodyInertia" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ArticulatedBodyInertia" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (iDynTree::ArticulatedBodyInertia *)new iDynTree::ArticulatedBodyInertia((double const *)arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ArticulatedBodyInertia__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialInertia *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ArticulatedBodyInertia *result = 0 ;
  
  if (!SWIG_check_num_args("new_ArticulatedBodyInertia",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialInertia,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArticulatedBodyInertia" "', argument " "1"" of type '" "iDynTree::SpatialInertia const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArticulatedBodyInertia" "', argument " "1"" of type '" "iDynTree::SpatialInertia const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialInertia * >(argp1);
  result = (iDynTree::ArticulatedBodyInertia *)new iDynTree::ArticulatedBodyInertia((iDynTree::SpatialInertia const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ArticulatedBodyInertia__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ArticulatedBodyInertia *result = 0 ;
  
  if (!SWIG_check_num_args("new_ArticulatedBodyInertia",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArticulatedBodyInertia" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArticulatedBodyInertia" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  result = (iDynTree::ArticulatedBodyInertia *)new iDynTree::ArticulatedBodyInertia((iDynTree::ArticulatedBodyInertia const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ArticulatedBodyInertia(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_ArticulatedBodyInertia__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpatialInertia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ArticulatedBodyInertia__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ArticulatedBodyInertia__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ArticulatedBodyInertia__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_ArticulatedBodyInertia'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ArticulatedBodyInertia::ArticulatedBodyInertia()\n"
    "    iDynTree::ArticulatedBodyInertia::ArticulatedBodyInertia(double const *,unsigned int const,unsigned int const)\n"
    "    iDynTree::ArticulatedBodyInertia::ArticulatedBodyInertia(iDynTree::SpatialInertia const &)\n"
    "    iDynTree::ArticulatedBodyInertia::ArticulatedBodyInertia(iDynTree::ArticulatedBodyInertia const &)\n");
  return 1;
}


int _wrap_ArticulatedBodyInertia_getLinearLinearSubmatrix__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix3x3 *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_getLinearLinearSubmatrix",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_getLinearLinearSubmatrix" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  result = (iDynTree::Matrix3x3 *) &(arg1)->getLinearLinearSubmatrix();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_getLinearAngularSubmatrix__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix3x3 *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_getLinearAngularSubmatrix",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_getLinearAngularSubmatrix" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  result = (iDynTree::Matrix3x3 *) &(arg1)->getLinearAngularSubmatrix();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_getAngularAngularSubmatrix__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix3x3 *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_getAngularAngularSubmatrix",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_getAngularAngularSubmatrix" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  result = (iDynTree::Matrix3x3 *) &(arg1)->getAngularAngularSubmatrix();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_getLinearLinearSubmatrix__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix3x3 *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_getLinearLinearSubmatrix",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_getLinearLinearSubmatrix" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  result = (iDynTree::Matrix3x3 *) &((iDynTree::ArticulatedBodyInertia const *)arg1)->getLinearLinearSubmatrix();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_getLinearLinearSubmatrix(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ArticulatedBodyInertia_getLinearLinearSubmatrix__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ArticulatedBodyInertia_getLinearLinearSubmatrix__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ArticulatedBodyInertia_getLinearLinearSubmatrix'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ArticulatedBodyInertia::getLinearLinearSubmatrix()\n"
    "    iDynTree::ArticulatedBodyInertia::getLinearLinearSubmatrix() const\n");
  return 1;
}


int _wrap_ArticulatedBodyInertia_getLinearAngularSubmatrix__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix3x3 *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_getLinearAngularSubmatrix",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_getLinearAngularSubmatrix" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  result = (iDynTree::Matrix3x3 *) &((iDynTree::ArticulatedBodyInertia const *)arg1)->getLinearAngularSubmatrix();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_getLinearAngularSubmatrix(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ArticulatedBodyInertia_getLinearAngularSubmatrix__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ArticulatedBodyInertia_getLinearAngularSubmatrix__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ArticulatedBodyInertia_getLinearAngularSubmatrix'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ArticulatedBodyInertia::getLinearAngularSubmatrix()\n"
    "    iDynTree::ArticulatedBodyInertia::getLinearAngularSubmatrix() const\n");
  return 1;
}


int _wrap_ArticulatedBodyInertia_getAngularAngularSubmatrix__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix3x3 *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_getAngularAngularSubmatrix",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_getAngularAngularSubmatrix" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  result = (iDynTree::Matrix3x3 *) &((iDynTree::ArticulatedBodyInertia const *)arg1)->getAngularAngularSubmatrix();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_getAngularAngularSubmatrix(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ArticulatedBodyInertia_getAngularAngularSubmatrix__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ArticulatedBodyInertia_getAngularAngularSubmatrix__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ArticulatedBodyInertia_getAngularAngularSubmatrix'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ArticulatedBodyInertia::getAngularAngularSubmatrix()\n"
    "    iDynTree::ArticulatedBodyInertia::getAngularAngularSubmatrix() const\n");
  return 1;
}


int _wrap_ArticulatedBodyInertia_combine(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = 0 ;
  iDynTree::ArticulatedBodyInertia *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::ArticulatedBodyInertia result;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_combine",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_combine" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyInertia_combine" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyInertia_combine" "', argument " "2"" of type '" "iDynTree::ArticulatedBodyInertia const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyInertia_combine" "', argument " "2"" of type '" "iDynTree::ArticulatedBodyInertia const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp2);
  result = iDynTree::ArticulatedBodyInertia::combine((iDynTree::ArticulatedBodyInertia const &)*arg1,(iDynTree::ArticulatedBodyInertia const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::ArticulatedBodyInertia(static_cast< const iDynTree::ArticulatedBodyInertia& >(result))), SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_applyInverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  iDynTree::Wrench *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc result;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_applyInverse",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_applyInverse" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyInertia_applyInverse" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyInertia_applyInverse" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Wrench * >(argp2);
  result = ((iDynTree::ArticulatedBodyInertia const *)arg1)->applyInverse((iDynTree::Wrench const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialAcc(static_cast< const iDynTree::SpatialAcc& >(result))), SWIGTYPE_p_iDynTree__SpatialAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_asMatrix(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix6x6 result;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_asMatrix",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_asMatrix" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  result = ((iDynTree::ArticulatedBodyInertia const *)arg1)->asMatrix();
  _out = SWIG_NewPointerObj((new iDynTree::Matrix6x6(static_cast< const iDynTree::Matrix6x6& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_getInverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix6x6 result;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_getInverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_getInverse" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  result = ((iDynTree::ArticulatedBodyInertia const *)arg1)->getInverse();
  _out = SWIG_NewPointerObj((new iDynTree::Matrix6x6(static_cast< const iDynTree::Matrix6x6& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_plus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  iDynTree::ArticulatedBodyInertia *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::ArticulatedBodyInertia result;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_plus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_plus" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyInertia_plus" "', argument " "2"" of type '" "iDynTree::ArticulatedBodyInertia const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyInertia_plus" "', argument " "2"" of type '" "iDynTree::ArticulatedBodyInertia const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp2);
  result = ((iDynTree::ArticulatedBodyInertia const *)arg1)->operator +((iDynTree::ArticulatedBodyInertia const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::ArticulatedBodyInertia(static_cast< const iDynTree::ArticulatedBodyInertia& >(result))), SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_minus(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  iDynTree::ArticulatedBodyInertia *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::ArticulatedBodyInertia result;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_minus",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_minus" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyInertia_minus" "', argument " "2"" of type '" "iDynTree::ArticulatedBodyInertia const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyInertia_minus" "', argument " "2"" of type '" "iDynTree::ArticulatedBodyInertia const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp2);
  result = ((iDynTree::ArticulatedBodyInertia const *)arg1)->operator -((iDynTree::ArticulatedBodyInertia const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::ArticulatedBodyInertia(static_cast< const iDynTree::ArticulatedBodyInertia& >(result))), SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_mtimes__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  iDynTree::SpatialMotionVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_mtimes" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyInertia_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyInertia_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp2);
  result = ((iDynTree::ArticulatedBodyInertia const *)arg1)->operator *((iDynTree::SpatialMotionVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_mtimes__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  iDynTree::SpatialAcc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Wrench result;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_mtimes" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyInertia_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyInertia_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialAcc * >(argp2);
  result = ((iDynTree::ArticulatedBodyInertia const *)arg1)->operator *((iDynTree::SpatialAcc const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Wrench(static_cast< const iDynTree::Wrench& >(result))), SWIGTYPE_p_iDynTree__Wrench, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_mtimes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialAcc, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ArticulatedBodyInertia_mtimes__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionVector, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ArticulatedBodyInertia_mtimes__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ArticulatedBodyInertia_mtimes'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ArticulatedBodyInertia::operator *(iDynTree::SpatialMotionVector const &) const\n"
    "    iDynTree::ArticulatedBodyInertia::operator *(iDynTree::SpatialAcc const &) const\n");
  return 1;
}


int _wrap_ArticulatedBodyInertia_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_zero" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_ABADyadHelper(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialForceVector *arg1 = 0 ;
  double arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::ArticulatedBodyInertia result;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_ABADyadHelper",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_ABADyadHelper" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyInertia_ABADyadHelper" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArticulatedBodyInertia_ABADyadHelper" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = iDynTree::ArticulatedBodyInertia::ABADyadHelper((iDynTree::SpatialForceVector const &)*arg1,arg2);
  _out = SWIG_NewPointerObj((new iDynTree::ArticulatedBodyInertia(static_cast< const iDynTree::ArticulatedBodyInertia& >(result))), SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyInertia_ABADyadHelperLin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SpatialForceVector *arg1 = 0 ;
  double arg2 ;
  iDynTree::SpatialForceVector *arg3 = 0 ;
  double arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  iDynTree::ArticulatedBodyInertia result;
  
  if (!SWIG_check_num_args("ArticulatedBodyInertia_ABADyadHelperLin",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyInertia_ABADyadHelperLin" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyInertia_ABADyadHelperLin" "', argument " "1"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ArticulatedBodyInertia_ABADyadHelperLin" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ArticulatedBodyInertia_ABADyadHelperLin" "', argument " "3"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyInertia_ABADyadHelperLin" "', argument " "3"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ArticulatedBodyInertia_ABADyadHelperLin" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = iDynTree::ArticulatedBodyInertia::ABADyadHelperLin((iDynTree::SpatialForceVector const &)*arg1,arg2,(iDynTree::SpatialForceVector const &)*arg3,arg4);
  _out = SWIG_NewPointerObj((new iDynTree::ArticulatedBodyInertia(static_cast< const iDynTree::ArticulatedBodyInertia& >(result))), SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ArticulatedBodyInertia(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyInertia *arg1 = (iDynTree::ArticulatedBodyInertia *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ArticulatedBodyInertia",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArticulatedBodyInertia" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyInertia *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_mass_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_mass_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_mass_set" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RigidBodyInertiaNonLinearParametrization_mass_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->mass = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_mass_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_mass_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_mass_get" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  result = (double) ((arg1)->mass);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_com_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  iDynTree::Position *arg2 = (iDynTree::Position *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_com_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_com_set" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RigidBodyInertiaNonLinearParametrization_com_set" "', argument " "2"" of type '" "iDynTree::Position *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  if (arg1) (arg1)->com = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_com_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_com_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_com_get" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  result = (iDynTree::Position *)& ((arg1)->com);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_link_R_centroidal_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  iDynTree::Rotation *arg2 = (iDynTree::Rotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_link_R_centroidal_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_link_R_centroidal_set" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RigidBodyInertiaNonLinearParametrization_link_R_centroidal_set" "', argument " "2"" of type '" "iDynTree::Rotation *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Rotation * >(argp2);
  if (arg1) (arg1)->link_R_centroidal = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_link_R_centroidal_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Rotation *result = 0 ;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_link_R_centroidal_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_link_R_centroidal_get" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  result = (iDynTree::Rotation *)& ((arg1)->link_R_centroidal);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_centralSecondMomentOfMass_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  iDynTree::Vector3 *arg2 = (iDynTree::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_centralSecondMomentOfMass_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_centralSecondMomentOfMass_set" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RigidBodyInertiaNonLinearParametrization_centralSecondMomentOfMass_set" "', argument " "2"" of type '" "iDynTree::Vector3 *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector3 * >(argp2);
  if (arg1) (arg1)->centralSecondMomentOfMass = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_centralSecondMomentOfMass_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Vector3 *result = 0 ;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_centralSecondMomentOfMass_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_centralSecondMomentOfMass_get" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  result = (iDynTree::Vector3 *)& ((arg1)->centralSecondMomentOfMass);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_getLinkCentroidalTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_getLinkCentroidalTransform",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_getLinkCentroidalTransform" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  result = ((iDynTree::RigidBodyInertiaNonLinearParametrization const *)arg1)->getLinkCentroidalTransform();
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_fromRigidBodyInertia(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  iDynTree::SpatialInertia *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_fromRigidBodyInertia",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_fromRigidBodyInertia" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialInertia,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RigidBodyInertiaNonLinearParametrization_fromRigidBodyInertia" "', argument " "2"" of type '" "iDynTree::SpatialInertia const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RigidBodyInertiaNonLinearParametrization_fromRigidBodyInertia" "', argument " "2"" of type '" "iDynTree::SpatialInertia const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialInertia * >(argp2);
  (arg1)->fromRigidBodyInertia((iDynTree::SpatialInertia const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_fromInertialParameters(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  iDynTree::Vector10 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_fromInertialParameters",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_fromInertialParameters" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_10_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RigidBodyInertiaNonLinearParametrization_fromInertialParameters" "', argument " "2"" of type '" "iDynTree::Vector10 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RigidBodyInertiaNonLinearParametrization_fromInertialParameters" "', argument " "2"" of type '" "iDynTree::Vector10 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector10 * >(argp2);
  (arg1)->fromInertialParameters((iDynTree::Vector10 const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_toRigidBodyInertia(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertia result;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_toRigidBodyInertia",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_toRigidBodyInertia" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  result = ((iDynTree::RigidBodyInertiaNonLinearParametrization const *)arg1)->toRigidBodyInertia();
  _out = SWIG_NewPointerObj((new iDynTree::SpatialInertia(static_cast< const iDynTree::SpatialInertia& >(result))), SWIGTYPE_p_iDynTree__SpatialInertia, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_isPhysicallyConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_isPhysicallyConsistent",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_isPhysicallyConsistent" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  result = (bool)((iDynTree::RigidBodyInertiaNonLinearParametrization const *)arg1)->isPhysicallyConsistent();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_asVectorWithRotationAsVec(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Vector16 result;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_asVectorWithRotationAsVec",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_asVectorWithRotationAsVec" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  result = ((iDynTree::RigidBodyInertiaNonLinearParametrization const *)arg1)->asVectorWithRotationAsVec();
  _out = SWIG_NewPointerObj((new iDynTree::Vector16(static_cast< const iDynTree::Vector16& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_fromVectorWithRotationAsVec(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  iDynTree::Vector16 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_fromVectorWithRotationAsVec",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_fromVectorWithRotationAsVec" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_16_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RigidBodyInertiaNonLinearParametrization_fromVectorWithRotationAsVec" "', argument " "2"" of type '" "iDynTree::Vector16 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RigidBodyInertiaNonLinearParametrization_fromVectorWithRotationAsVec" "', argument " "2"" of type '" "iDynTree::Vector16 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector16 * >(argp2);
  (arg1)->fromVectorWithRotationAsVec((iDynTree::Vector16 const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RigidBodyInertiaNonLinearParametrization_getGradientWithRotationAsVec(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix10x16 result;
  
  if (!SWIG_check_num_args("RigidBodyInertiaNonLinearParametrization_getGradientWithRotationAsVec",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RigidBodyInertiaNonLinearParametrization_getGradientWithRotationAsVec" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  result = ((iDynTree::RigidBodyInertiaNonLinearParametrization const *)arg1)->getGradientWithRotationAsVec();
  _out = SWIG_NewPointerObj((new iDynTree::Matrix10x16(static_cast< const iDynTree::Matrix10x16& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_10_16_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RigidBodyInertiaNonLinearParametrization(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::RigidBodyInertiaNonLinearParametrization *result = 0 ;
  
  if (!SWIG_check_num_args("new_RigidBodyInertiaNonLinearParametrization",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::RigidBodyInertiaNonLinearParametrization *)new iDynTree::RigidBodyInertiaNonLinearParametrization();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_RigidBodyInertiaNonLinearParametrization(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RigidBodyInertiaNonLinearParametrization *arg1 = (iDynTree::RigidBodyInertiaNonLinearParametrization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_RigidBodyInertiaNonLinearParametrization",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RigidBodyInertiaNonLinearParametrization, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RigidBodyInertiaNonLinearParametrization" "', argument " "1"" of type '" "iDynTree::RigidBodyInertiaNonLinearParametrization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RigidBodyInertiaNonLinearParametrization * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RotationRaw__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::RotationRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_RotationRaw",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::RotationRaw *)new iDynTree::RotationRaw();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RotationRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RotationRaw__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  mxArray * _out;
  iDynTree::RotationRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_RotationRaw",argc,9,9,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RotationRaw" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RotationRaw" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RotationRaw" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_RotationRaw" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_RotationRaw" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_RotationRaw" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_RotationRaw" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_RotationRaw" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(argv[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_RotationRaw" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (iDynTree::RotationRaw *)new iDynTree::RotationRaw(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RotationRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RotationRaw__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double *arg1 = (double *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::RotationRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_RotationRaw",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RotationRaw" "', argument " "1"" of type '" "double const *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RotationRaw" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_RotationRaw" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (iDynTree::RotationRaw *)new iDynTree::RotationRaw((double const *)arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RotationRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RotationRaw__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::MatrixView< double const > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::RotationRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_RotationRaw",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RotationRaw" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RotationRaw" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::MatrixView< double const > * >(argp1));
    }
  }
  result = (iDynTree::RotationRaw *)new iDynTree::RotationRaw(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RotationRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RotationRaw__SWIG_4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RotationRaw *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::RotationRaw *result = 0 ;
  
  if (!SWIG_check_num_args("new_RotationRaw",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__RotationRaw,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RotationRaw" "', argument " "1"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RotationRaw" "', argument " "1"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RotationRaw * >(argp1);
  result = (iDynTree::RotationRaw *)new iDynTree::RotationRaw((iDynTree::RotationRaw const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RotationRaw, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RotationRaw(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_RotationRaw__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RotationRaw__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__RotationRaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RotationRaw__SWIG_4(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_RotationRaw__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_RotationRaw__SWIG_1(resc,resv,argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_RotationRaw'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::RotationRaw::RotationRaw()\n"
    "    iDynTree::RotationRaw::RotationRaw(double,double,double,double,double,double,double,double,double)\n"
    "    iDynTree::RotationRaw::RotationRaw(double const *,unsigned int const,unsigned int const)\n"
    "    iDynTree::RotationRaw::RotationRaw(iDynTree::MatrixView< double const >)\n"
    "    iDynTree::RotationRaw::RotationRaw(iDynTree::RotationRaw const &)\n");
  return 1;
}


int _wrap_RotationRaw_changeOrientFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RotationRaw *arg1 = (iDynTree::RotationRaw *) 0 ;
  iDynTree::RotationRaw *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::RotationRaw *result = 0 ;
  
  if (!SWIG_check_num_args("RotationRaw_changeOrientFrame",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RotationRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotationRaw_changeOrientFrame" "', argument " "1"" of type '" "iDynTree::RotationRaw *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RotationRaw * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__RotationRaw,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotationRaw_changeOrientFrame" "', argument " "2"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotationRaw_changeOrientFrame" "', argument " "2"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::RotationRaw * >(argp2);
  result = (iDynTree::RotationRaw *) &(arg1)->changeOrientFrame((iDynTree::RotationRaw const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RotationRaw, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RotationRaw_changeRefOrientFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RotationRaw *arg1 = (iDynTree::RotationRaw *) 0 ;
  iDynTree::RotationRaw *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::RotationRaw *result = 0 ;
  
  if (!SWIG_check_num_args("RotationRaw_changeRefOrientFrame",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RotationRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotationRaw_changeRefOrientFrame" "', argument " "1"" of type '" "iDynTree::RotationRaw *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RotationRaw * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__RotationRaw,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotationRaw_changeRefOrientFrame" "', argument " "2"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotationRaw_changeRefOrientFrame" "', argument " "2"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::RotationRaw * >(argp2);
  result = (iDynTree::RotationRaw *) &(arg1)->changeRefOrientFrame((iDynTree::RotationRaw const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RotationRaw, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RotationRaw_compose(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RotationRaw *arg1 = 0 ;
  iDynTree::RotationRaw *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::RotationRaw result;
  
  if (!SWIG_check_num_args("RotationRaw_compose",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__RotationRaw,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotationRaw_compose" "', argument " "1"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotationRaw_compose" "', argument " "1"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RotationRaw * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__RotationRaw,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotationRaw_compose" "', argument " "2"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotationRaw_compose" "', argument " "2"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::RotationRaw * >(argp2);
  result = iDynTree::RotationRaw::compose((iDynTree::RotationRaw const &)*arg1,(iDynTree::RotationRaw const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::RotationRaw(static_cast< const iDynTree::RotationRaw& >(result))), SWIGTYPE_p_iDynTree__RotationRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RotationRaw_inverse2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RotationRaw *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::RotationRaw result;
  
  if (!SWIG_check_num_args("RotationRaw_inverse2",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__RotationRaw,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotationRaw_inverse2" "', argument " "1"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotationRaw_inverse2" "', argument " "1"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RotationRaw * >(argp1);
  result = iDynTree::RotationRaw::inverse2((iDynTree::RotationRaw const &)*arg1);
  _out = SWIG_NewPointerObj((new iDynTree::RotationRaw(static_cast< const iDynTree::RotationRaw& >(result))), SWIGTYPE_p_iDynTree__RotationRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RotationRaw_changeCoordFrameOf__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RotationRaw *arg1 = (iDynTree::RotationRaw *) 0 ;
  iDynTree::PositionRaw *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::PositionRaw result;
  
  if (!SWIG_check_num_args("RotationRaw_changeCoordFrameOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RotationRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotationRaw_changeCoordFrameOf" "', argument " "1"" of type '" "iDynTree::RotationRaw const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RotationRaw * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__PositionRaw,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotationRaw_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotationRaw_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::PositionRaw const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::PositionRaw * >(argp2);
  result = ((iDynTree::RotationRaw const *)arg1)->changeCoordFrameOf((iDynTree::PositionRaw const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::PositionRaw(static_cast< const iDynTree::PositionRaw& >(result))), SWIGTYPE_p_iDynTree__PositionRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RotationRaw_changeCoordFrameOf__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RotationRaw *arg1 = (iDynTree::RotationRaw *) 0 ;
  iDynTree::ClassicalAcc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::ClassicalAcc result;
  
  if (!SWIG_check_num_args("RotationRaw_changeCoordFrameOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RotationRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotationRaw_changeCoordFrameOf" "', argument " "1"" of type '" "iDynTree::RotationRaw const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RotationRaw * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ClassicalAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotationRaw_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::ClassicalAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotationRaw_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::ClassicalAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ClassicalAcc * >(argp2);
  result = ((iDynTree::RotationRaw const *)arg1)->changeCoordFrameOf((iDynTree::ClassicalAcc const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::ClassicalAcc(static_cast< const iDynTree::ClassicalAcc& >(result))), SWIGTYPE_p_iDynTree__ClassicalAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RotationRaw_changeCoordFrameOf__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RotationRaw *arg1 = (iDynTree::RotationRaw *) 0 ;
  iDynTree::RotationalInertiaRaw *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::RotationalInertiaRaw result;
  
  if (!SWIG_check_num_args("RotationRaw_changeCoordFrameOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RotationRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotationRaw_changeCoordFrameOf" "', argument " "1"" of type '" "iDynTree::RotationRaw const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RotationRaw * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__RotationalInertiaRaw,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotationRaw_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::RotationalInertiaRaw const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotationRaw_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::RotationalInertiaRaw const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::RotationalInertiaRaw * >(argp2);
  result = ((iDynTree::RotationRaw const *)arg1)->changeCoordFrameOf((iDynTree::RotationalInertiaRaw const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::RotationalInertiaRaw(static_cast< const iDynTree::RotationalInertiaRaw& >(result))), SWIGTYPE_p_iDynTree__RotationalInertiaRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RotationRaw_changeCoordFrameOf(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__RotationRaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__PositionRaw, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RotationRaw_changeCoordFrameOf__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__RotationRaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__ClassicalAcc, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RotationRaw_changeCoordFrameOf__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__RotationRaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__RotationalInertiaRaw, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RotationRaw_changeCoordFrameOf__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'RotationRaw_changeCoordFrameOf'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::RotationRaw::changeCoordFrameOf(iDynTree::PositionRaw const &) const\n"
    "    iDynTree::RotationRaw::changeCoordFrameOf(iDynTree::ClassicalAcc const &) const\n"
    "    iDynTree::RotationRaw::changeCoordFrameOf(iDynTree::RotationalInertiaRaw const &) const\n");
  return 1;
}


int _wrap_RotationRaw_RotX(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::RotationRaw result;
  
  if (!SWIG_check_num_args("RotationRaw_RotX",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RotationRaw_RotX" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = iDynTree::RotationRaw::RotX(arg1);
  _out = SWIG_NewPointerObj((new iDynTree::RotationRaw(static_cast< const iDynTree::RotationRaw& >(result))), SWIGTYPE_p_iDynTree__RotationRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RotationRaw_RotY(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::RotationRaw result;
  
  if (!SWIG_check_num_args("RotationRaw_RotY",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RotationRaw_RotY" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = iDynTree::RotationRaw::RotY(arg1);
  _out = SWIG_NewPointerObj((new iDynTree::RotationRaw(static_cast< const iDynTree::RotationRaw& >(result))), SWIGTYPE_p_iDynTree__RotationRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RotationRaw_RotZ(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::RotationRaw result;
  
  if (!SWIG_check_num_args("RotationRaw_RotZ",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RotationRaw_RotZ" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = iDynTree::RotationRaw::RotZ(arg1);
  _out = SWIG_NewPointerObj((new iDynTree::RotationRaw(static_cast< const iDynTree::RotationRaw& >(result))), SWIGTYPE_p_iDynTree__RotationRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RotationRaw_RPY(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::RotationRaw result;
  
  if (!SWIG_check_num_args("RotationRaw_RPY",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "RotationRaw_RPY" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RotationRaw_RPY" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RotationRaw_RPY" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = iDynTree::RotationRaw::RPY(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::RotationRaw(static_cast< const iDynTree::RotationRaw& >(result))), SWIGTYPE_p_iDynTree__RotationRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RotationRaw_Identity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::RotationRaw result;
  
  if (!SWIG_check_num_args("RotationRaw_Identity",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = iDynTree::RotationRaw::Identity();
  _out = SWIG_NewPointerObj((new iDynTree::RotationRaw(static_cast< const iDynTree::RotationRaw& >(result))), SWIGTYPE_p_iDynTree__RotationRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RotationRaw_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RotationRaw *arg1 = (iDynTree::RotationRaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("RotationRaw_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RotationRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotationRaw_toString" "', argument " "1"" of type '" "iDynTree::RotationRaw const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RotationRaw * >(argp1);
  result = ((iDynTree::RotationRaw const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RotationRaw_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RotationRaw *arg1 = (iDynTree::RotationRaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("RotationRaw_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RotationRaw, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotationRaw_display" "', argument " "1"" of type '" "iDynTree::RotationRaw const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RotationRaw * >(argp1);
  result = ((iDynTree::RotationRaw const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_RotationRaw(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RotationRaw *arg1 = (iDynTree::RotationRaw *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_RotationRaw",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RotationRaw, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RotationRaw" "', argument " "1"" of type '" "iDynTree::RotationRaw *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RotationRaw * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Rotation__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Rotation *result = 0 ;
  
  if (!SWIG_check_num_args("new_Rotation",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Rotation *)new iDynTree::Rotation();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Rotation, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Rotation__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  mxArray * _out;
  iDynTree::Rotation *result = 0 ;
  
  if (!SWIG_check_num_args("new_Rotation",argc,9,9,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rotation" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rotation" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rotation" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rotation" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Rotation" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Rotation" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Rotation" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  ecode8 = SWIG_AsVal_double(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Rotation" "', argument " "8"" of type '" "double""'");
  } 
  arg8 = static_cast< double >(val8);
  ecode9 = SWIG_AsVal_double(argv[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Rotation" "', argument " "9"" of type '" "double""'");
  } 
  arg9 = static_cast< double >(val9);
  result = (iDynTree::Rotation *)new iDynTree::Rotation(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Rotation, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Rotation__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RotationRaw *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Rotation *result = 0 ;
  
  if (!SWIG_check_num_args("new_Rotation",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__RotationRaw,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rotation" "', argument " "1"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rotation" "', argument " "1"" of type '" "iDynTree::RotationRaw const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RotationRaw * >(argp1);
  result = (iDynTree::Rotation *)new iDynTree::Rotation((iDynTree::RotationRaw const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Rotation, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Rotation__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Rotation *result = 0 ;
  
  if (!SWIG_check_num_args("new_Rotation",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rotation" "', argument " "1"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rotation" "', argument " "1"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  result = (iDynTree::Rotation *)new iDynTree::Rotation((iDynTree::Rotation const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Rotation, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Rotation__SWIG_4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  SwigValueWrapper< iDynTree::MatrixView< double const > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Rotation *result = 0 ;
  
  if (!SWIG_check_num_args("new_Rotation",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rotation" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rotation" "', argument " "1"" of type '" "iDynTree::MatrixView< double const >""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::MatrixView< double const > * >(argp1));
    }
  }
  result = (iDynTree::Rotation *)new iDynTree::Rotation(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Rotation, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Rotation(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Rotation__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Rotation__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__RotationRaw, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Rotation__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Rotation__SWIG_4(resc,resv,argc,argv);
    }
  }
  if (argc == 9) {
    int _v;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_double(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_double(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_double(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_double(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_Rotation__SWIG_1(resc,resv,argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Rotation'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Rotation::Rotation()\n"
    "    iDynTree::Rotation::Rotation(double,double,double,double,double,double,double,double,double)\n"
    "    iDynTree::Rotation::Rotation(iDynTree::RotationRaw const &)\n"
    "    iDynTree::Rotation::Rotation(iDynTree::Rotation const &)\n"
    "    iDynTree::Rotation::Rotation(iDynTree::MatrixView< double const >)\n");
  return 1;
}


int _wrap_Rotation_changeOrientFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Rotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Rotation *result = 0 ;
  
  if (!SWIG_check_num_args("Rotation_changeOrientFrame",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_changeOrientFrame" "', argument " "1"" of type '" "iDynTree::Rotation *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_changeOrientFrame" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_changeOrientFrame" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Rotation * >(argp2);
  result = (iDynTree::Rotation *) &(arg1)->changeOrientFrame((iDynTree::Rotation const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_changeRefOrientFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Rotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Rotation *result = 0 ;
  
  if (!SWIG_check_num_args("Rotation_changeRefOrientFrame",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_changeRefOrientFrame" "', argument " "1"" of type '" "iDynTree::Rotation *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_changeRefOrientFrame" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_changeRefOrientFrame" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Rotation * >(argp2);
  result = (iDynTree::Rotation *) &(arg1)->changeRefOrientFrame((iDynTree::Rotation const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_changeCoordinateFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Rotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Rotation *result = 0 ;
  
  if (!SWIG_check_num_args("Rotation_changeCoordinateFrame",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_changeCoordinateFrame" "', argument " "1"" of type '" "iDynTree::Rotation *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_changeCoordinateFrame" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_changeCoordinateFrame" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Rotation * >(argp2);
  result = (iDynTree::Rotation *) &(arg1)->changeCoordinateFrame((iDynTree::Rotation const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_compose(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = 0 ;
  iDynTree::Rotation *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Rotation result;
  
  if (!SWIG_check_num_args("Rotation_compose",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_compose" "', argument " "1"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_compose" "', argument " "1"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_compose" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_compose" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Rotation * >(argp2);
  result = iDynTree::Rotation::compose((iDynTree::Rotation const &)*arg1,(iDynTree::Rotation const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Rotation(static_cast< const iDynTree::Rotation& >(result))), SWIGTYPE_p_iDynTree__Rotation, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_inverse2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Rotation result;
  
  if (!SWIG_check_num_args("Rotation_inverse2",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_inverse2" "', argument " "1"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_inverse2" "', argument " "1"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  result = iDynTree::Rotation::inverse2((iDynTree::Rotation const &)*arg1);
  _out = SWIG_NewPointerObj((new iDynTree::Rotation(static_cast< const iDynTree::Rotation& >(result))), SWIGTYPE_p_iDynTree__Rotation, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_changeCoordFrameOf__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Position result;
  
  if (!SWIG_check_num_args("Rotation_changeCoordFrameOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_changeCoordFrameOf" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->changeCoordFrameOf((iDynTree::Position const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_changeCoordFrameOf__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::SpatialMotionVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("Rotation_changeCoordFrameOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_changeCoordFrameOf" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->changeCoordFrameOf((iDynTree::SpatialMotionVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_changeCoordFrameOf__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::SpatialForceVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("Rotation_changeCoordFrameOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_changeCoordFrameOf" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->changeCoordFrameOf((iDynTree::SpatialForceVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_changeCoordFrameOf__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Twist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("Rotation_changeCoordFrameOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_changeCoordFrameOf" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Twist * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->changeCoordFrameOf((iDynTree::Twist const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_changeCoordFrameOf__SWIG_4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::SpatialAcc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc result;
  
  if (!SWIG_check_num_args("Rotation_changeCoordFrameOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_changeCoordFrameOf" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialAcc * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->changeCoordFrameOf((iDynTree::SpatialAcc const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialAcc(static_cast< const iDynTree::SpatialAcc& >(result))), SWIGTYPE_p_iDynTree__SpatialAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_changeCoordFrameOf__SWIG_5(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::SpatialMomentum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMomentum result;
  
  if (!SWIG_check_num_args("Rotation_changeCoordFrameOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_changeCoordFrameOf" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMomentum,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->changeCoordFrameOf((iDynTree::SpatialMomentum const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMomentum(static_cast< const iDynTree::SpatialMomentum& >(result))), SWIGTYPE_p_iDynTree__SpatialMomentum, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_changeCoordFrameOf__SWIG_6(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Wrench *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Wrench result;
  
  if (!SWIG_check_num_args("Rotation_changeCoordFrameOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_changeCoordFrameOf" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Wrench * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->changeCoordFrameOf((iDynTree::Wrench const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Wrench(static_cast< const iDynTree::Wrench& >(result))), SWIGTYPE_p_iDynTree__Wrench, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_changeCoordFrameOf__SWIG_7(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Direction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Direction result;
  
  if (!SWIG_check_num_args("Rotation_changeCoordFrameOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_changeCoordFrameOf" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Direction * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->changeCoordFrameOf((iDynTree::Direction const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Direction(static_cast< const iDynTree::Direction& >(result))), SWIGTYPE_p_iDynTree__Direction, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_changeCoordFrameOf__SWIG_8(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Axis *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Axis result;
  
  if (!SWIG_check_num_args("Rotation_changeCoordFrameOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_changeCoordFrameOf" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Axis,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Axis * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->changeCoordFrameOf((iDynTree::Axis const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Axis(static_cast< const iDynTree::Axis& >(result))), SWIGTYPE_p_iDynTree__Axis, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_changeCoordFrameOf__SWIG_9(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::ClassicalAcc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::ClassicalAcc result;
  
  if (!SWIG_check_num_args("Rotation_changeCoordFrameOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_changeCoordFrameOf" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ClassicalAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::ClassicalAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::ClassicalAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ClassicalAcc * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->changeCoordFrameOf((iDynTree::ClassicalAcc const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::ClassicalAcc(static_cast< const iDynTree::ClassicalAcc& >(result))), SWIGTYPE_p_iDynTree__ClassicalAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_changeCoordFrameOf__SWIG_10(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::RotationalInertiaRaw *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::RotationalInertiaRaw result;
  
  if (!SWIG_check_num_args("Rotation_changeCoordFrameOf",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_changeCoordFrameOf" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__RotationalInertiaRaw,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::RotationalInertiaRaw const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_changeCoordFrameOf" "', argument " "2"" of type '" "iDynTree::RotationalInertiaRaw const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::RotationalInertiaRaw * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->changeCoordFrameOf((iDynTree::RotationalInertiaRaw const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::RotationalInertiaRaw(static_cast< const iDynTree::RotationalInertiaRaw& >(result))), SWIGTYPE_p_iDynTree__RotationalInertiaRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_changeCoordFrameOf(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_changeCoordFrameOf__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Twist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_changeCoordFrameOf__SWIG_3(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMomentum, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_changeCoordFrameOf__SWIG_5(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialAcc, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_changeCoordFrameOf__SWIG_4(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionVector, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_changeCoordFrameOf__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Wrench, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_changeCoordFrameOf__SWIG_6(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialForceVector, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_changeCoordFrameOf__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_changeCoordFrameOf__SWIG_7(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_changeCoordFrameOf__SWIG_8(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__ClassicalAcc, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_changeCoordFrameOf__SWIG_9(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__RotationalInertiaRaw, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_changeCoordFrameOf__SWIG_10(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Rotation_changeCoordFrameOf'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Rotation::changeCoordFrameOf(iDynTree::Position const &) const\n"
    "    iDynTree::Rotation::changeCoordFrameOf(iDynTree::SpatialMotionVector const &) const\n"
    "    iDynTree::Rotation::changeCoordFrameOf(iDynTree::SpatialForceVector const &) const\n"
    "    iDynTree::Rotation::changeCoordFrameOf(iDynTree::Twist const &) const\n"
    "    iDynTree::Rotation::changeCoordFrameOf(iDynTree::SpatialAcc const &) const\n"
    "    iDynTree::Rotation::changeCoordFrameOf(iDynTree::SpatialMomentum const &) const\n"
    "    iDynTree::Rotation::changeCoordFrameOf(iDynTree::Wrench const &) const\n"
    "    iDynTree::Rotation::changeCoordFrameOf(iDynTree::Direction const &) const\n"
    "    iDynTree::Rotation::changeCoordFrameOf(iDynTree::Axis const &) const\n"
    "    iDynTree::Rotation::changeCoordFrameOf(iDynTree::ClassicalAcc const &) const\n"
    "    iDynTree::Rotation::changeCoordFrameOf(iDynTree::RotationalInertiaRaw const &) const\n");
  return 1;
}


int _wrap_Rotation_mtimes__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Rotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Rotation result;
  
  if (!SWIG_check_num_args("Rotation_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_mtimes" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Rotation * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->operator *((iDynTree::Rotation const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Rotation(static_cast< const iDynTree::Rotation& >(result))), SWIGTYPE_p_iDynTree__Rotation, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_inverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Rotation result;
  
  if (!SWIG_check_num_args("Rotation_inverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_inverse" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  result = ((iDynTree::Rotation const *)arg1)->inverse();
  _out = SWIG_NewPointerObj((new iDynTree::Rotation(static_cast< const iDynTree::Rotation& >(result))), SWIGTYPE_p_iDynTree__Rotation, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_mtimes__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Position result;
  
  if (!SWIG_check_num_args("Rotation_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_mtimes" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->operator *((iDynTree::Position const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_mtimes__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::SpatialForceVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("Rotation_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_mtimes" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->operator *((iDynTree::SpatialForceVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_mtimes__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Twist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("Rotation_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_mtimes" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Twist * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->operator *((iDynTree::Twist const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_mtimes__SWIG_4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Wrench *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Wrench result;
  
  if (!SWIG_check_num_args("Rotation_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_mtimes" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Wrench * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->operator *((iDynTree::Wrench const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Wrench(static_cast< const iDynTree::Wrench& >(result))), SWIGTYPE_p_iDynTree__Wrench, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_mtimes__SWIG_5(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Direction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Direction result;
  
  if (!SWIG_check_num_args("Rotation_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_mtimes" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Direction * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->operator *((iDynTree::Direction const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Direction(static_cast< const iDynTree::Direction& >(result))), SWIGTYPE_p_iDynTree__Direction, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_mtimes__SWIG_6(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Axis *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Axis result;
  
  if (!SWIG_check_num_args("Rotation_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_mtimes" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Axis,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Axis * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->operator *((iDynTree::Axis const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Axis(static_cast< const iDynTree::Axis& >(result))), SWIGTYPE_p_iDynTree__Axis, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_mtimes__SWIG_7(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::SpatialAcc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc result;
  
  if (!SWIG_check_num_args("Rotation_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_mtimes" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialAcc * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->operator *((iDynTree::SpatialAcc const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialAcc(static_cast< const iDynTree::SpatialAcc& >(result))), SWIGTYPE_p_iDynTree__SpatialAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_mtimes__SWIG_8(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::SpatialMomentum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMomentum result;
  
  if (!SWIG_check_num_args("Rotation_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_mtimes" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMomentum,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->operator *((iDynTree::SpatialMomentum const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMomentum(static_cast< const iDynTree::SpatialMomentum& >(result))), SWIGTYPE_p_iDynTree__SpatialMomentum, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_mtimes__SWIG_9(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::ClassicalAcc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::ClassicalAcc result;
  
  if (!SWIG_check_num_args("Rotation_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_mtimes" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ClassicalAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::ClassicalAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::ClassicalAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ClassicalAcc * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->operator *((iDynTree::ClassicalAcc const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::ClassicalAcc(static_cast< const iDynTree::ClassicalAcc& >(result))), SWIGTYPE_p_iDynTree__ClassicalAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_mtimes__SWIG_10(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::RotationalInertiaRaw *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::RotationalInertiaRaw result;
  
  if (!SWIG_check_num_args("Rotation_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_mtimes" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__RotationalInertiaRaw,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::RotationalInertiaRaw const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_mtimes" "', argument " "2"" of type '" "iDynTree::RotationalInertiaRaw const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::RotationalInertiaRaw * >(argp2);
  result = ((iDynTree::Rotation const *)arg1)->operator *((iDynTree::RotationalInertiaRaw const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::RotationalInertiaRaw(static_cast< const iDynTree::RotationalInertiaRaw& >(result))), SWIGTYPE_p_iDynTree__RotationalInertiaRaw, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_mtimes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_mtimes__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_mtimes__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Wrench, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_mtimes__SWIG_4(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Twist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_mtimes__SWIG_3(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMomentum, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_mtimes__SWIG_8(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_mtimes__SWIG_5(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_mtimes__SWIG_6(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialAcc, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_mtimes__SWIG_7(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialForceVector, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_mtimes__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__ClassicalAcc, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_mtimes__SWIG_9(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__RotationalInertiaRaw, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_mtimes__SWIG_10(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Rotation_mtimes'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Rotation::operator *(iDynTree::Rotation const &) const\n"
    "    iDynTree::Rotation::operator *(iDynTree::Position const &) const\n"
    "    iDynTree::Rotation::operator *(iDynTree::SpatialForceVector const &) const\n"
    "    iDynTree::Rotation::operator *(iDynTree::Twist const &) const\n"
    "    iDynTree::Rotation::operator *(iDynTree::Wrench const &) const\n"
    "    iDynTree::Rotation::operator *(iDynTree::Direction const &) const\n"
    "    iDynTree::Rotation::operator *(iDynTree::Axis const &) const\n"
    "    iDynTree::Rotation::operator *(iDynTree::SpatialAcc const &) const\n"
    "    iDynTree::Rotation::operator *(iDynTree::SpatialMomentum const &) const\n"
    "    iDynTree::Rotation::operator *(iDynTree::ClassicalAcc const &) const\n"
    "    iDynTree::Rotation::operator *(iDynTree::RotationalInertiaRaw const &) const\n");
  return 1;
}


int _wrap_Rotation_log(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::AngularMotionVector3 result;
  
  if (!SWIG_check_num_args("Rotation_log",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_log" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  result = ((iDynTree::Rotation const *)arg1)->log();
  _out = SWIG_NewPointerObj((new iDynTree::AngularMotionVector3(static_cast< const iDynTree::AngularMotionVector3& >(result))), SWIGTYPE_p_iDynTree__GeomVector3, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_fromQuaternion(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Vector4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Rotation_fromQuaternion",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_fromQuaternion" "', argument " "1"" of type '" "iDynTree::Rotation *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_fromQuaternion" "', argument " "2"" of type '" "iDynTree::Vector4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_fromQuaternion" "', argument " "2"" of type '" "iDynTree::Vector4 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector4 * >(argp2);
  (arg1)->fromQuaternion((iDynTree::Vector4 const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_getRPY(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Rotation_getRPY",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_getRPY" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_getRPY" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_getRPY" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rotation_getRPY" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_getRPY" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rotation_getRPY" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_getRPY" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  ((iDynTree::Rotation const *)arg1)->getRPY(*arg2,*arg3,*arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_asRPY(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Vector3 result;
  
  if (!SWIG_check_num_args("Rotation_asRPY",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_asRPY" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  result = ((iDynTree::Rotation const *)arg1)->asRPY();
  _out = SWIG_NewPointerObj((new iDynTree::Vector3(static_cast< const iDynTree::Vector3& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_getQuaternion__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  iDynTree::Vector4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Rotation_getQuaternion",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_getQuaternion" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_getQuaternion" "', argument " "2"" of type '" "iDynTree::Vector4 &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_getQuaternion" "', argument " "2"" of type '" "iDynTree::Vector4 &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector4 * >(argp2);
  result = (bool)((iDynTree::Rotation const *)arg1)->getQuaternion(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_getQuaternion__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  double *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Rotation_getQuaternion",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_getQuaternion" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rotation_getQuaternion" "', argument " "2"" of type '" "double &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_getQuaternion" "', argument " "2"" of type '" "double &""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rotation_getQuaternion" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_getQuaternion" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rotation_getQuaternion" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_getQuaternion" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rotation_getQuaternion" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_getQuaternion" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  result = (bool)((iDynTree::Rotation const *)arg1)->getQuaternion(*arg2,*arg3,*arg4,*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_getQuaternion(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Rotation_getQuaternion__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Rotation_getQuaternion__SWIG_1(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Rotation_getQuaternion'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Rotation::getQuaternion(iDynTree::Vector4 &) const\n"
    "    iDynTree::Rotation::getQuaternion(double &,double &,double &,double &) const\n");
  return 1;
}


int _wrap_Rotation_asQuaternion(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Vector4 result;
  
  if (!SWIG_check_num_args("Rotation_asQuaternion",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_asQuaternion" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  result = ((iDynTree::Rotation const *)arg1)->asQuaternion();
  _out = SWIG_NewPointerObj((new iDynTree::Vector4(static_cast< const iDynTree::Vector4& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_RotX(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::Rotation result;
  
  if (!SWIG_check_num_args("Rotation_RotX",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Rotation_RotX" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = iDynTree::Rotation::RotX(arg1);
  _out = SWIG_NewPointerObj((new iDynTree::Rotation(static_cast< const iDynTree::Rotation& >(result))), SWIGTYPE_p_iDynTree__Rotation, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_RotY(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::Rotation result;
  
  if (!SWIG_check_num_args("Rotation_RotY",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Rotation_RotY" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = iDynTree::Rotation::RotY(arg1);
  _out = SWIG_NewPointerObj((new iDynTree::Rotation(static_cast< const iDynTree::Rotation& >(result))), SWIGTYPE_p_iDynTree__Rotation, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_RotZ(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::Rotation result;
  
  if (!SWIG_check_num_args("Rotation_RotZ",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Rotation_RotZ" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  result = iDynTree::Rotation::RotZ(arg1);
  _out = SWIG_NewPointerObj((new iDynTree::Rotation(static_cast< const iDynTree::Rotation& >(result))), SWIGTYPE_p_iDynTree__Rotation, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_RotAxis(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Direction *arg1 = 0 ;
  double arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Rotation result;
  
  if (!SWIG_check_num_args("Rotation_RotAxis",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_RotAxis" "', argument " "1"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_RotAxis" "', argument " "1"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Direction * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rotation_RotAxis" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = iDynTree::Rotation::RotAxis((iDynTree::Direction const &)*arg1,arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Rotation(static_cast< const iDynTree::Rotation& >(result))), SWIGTYPE_p_iDynTree__Rotation, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_RotAxisDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Direction *arg1 = 0 ;
  double arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Matrix3x3 result;
  
  if (!SWIG_check_num_args("Rotation_RotAxisDerivative",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_RotAxisDerivative" "', argument " "1"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_RotAxisDerivative" "', argument " "1"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Direction * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rotation_RotAxisDerivative" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  result = iDynTree::Rotation::RotAxisDerivative((iDynTree::Direction const &)*arg1,arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Matrix3x3(static_cast< const iDynTree::Matrix3x3& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_RPY(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::Rotation result;
  
  if (!SWIG_check_num_args("Rotation_RPY",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Rotation_RPY" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rotation_RPY" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rotation_RPY" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = iDynTree::Rotation::RPY(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Rotation(static_cast< const iDynTree::Rotation& >(result))), SWIGTYPE_p_iDynTree__Rotation, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_RPYRightTrivializedDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::Matrix3x3 result;
  
  if (!SWIG_check_num_args("Rotation_RPYRightTrivializedDerivative",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Rotation_RPYRightTrivializedDerivative" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rotation_RPYRightTrivializedDerivative" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rotation_RPYRightTrivializedDerivative" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = iDynTree::Rotation::RPYRightTrivializedDerivative(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Matrix3x3(static_cast< const iDynTree::Matrix3x3& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_RPYRightTrivializedDerivativeRateOfChange(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  mxArray * _out;
  iDynTree::Matrix3x3 result;
  
  if (!SWIG_check_num_args("Rotation_RPYRightTrivializedDerivativeRateOfChange",argc,6,6,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Rotation_RPYRightTrivializedDerivativeRateOfChange" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rotation_RPYRightTrivializedDerivativeRateOfChange" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rotation_RPYRightTrivializedDerivativeRateOfChange" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rotation_RPYRightTrivializedDerivativeRateOfChange" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rotation_RPYRightTrivializedDerivativeRateOfChange" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Rotation_RPYRightTrivializedDerivativeRateOfChange" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = iDynTree::Rotation::RPYRightTrivializedDerivativeRateOfChange(arg1,arg2,arg3,arg4,arg5,arg6);
  _out = SWIG_NewPointerObj((new iDynTree::Matrix3x3(static_cast< const iDynTree::Matrix3x3& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_RPYRightTrivializedDerivativeInverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::Matrix3x3 result;
  
  if (!SWIG_check_num_args("Rotation_RPYRightTrivializedDerivativeInverse",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Rotation_RPYRightTrivializedDerivativeInverse" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rotation_RPYRightTrivializedDerivativeInverse" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rotation_RPYRightTrivializedDerivativeInverse" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = iDynTree::Rotation::RPYRightTrivializedDerivativeInverse(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Matrix3x3(static_cast< const iDynTree::Matrix3x3& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_RPYRightTrivializedDerivativeInverseRateOfChange(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  mxArray * _out;
  iDynTree::Matrix3x3 result;
  
  if (!SWIG_check_num_args("Rotation_RPYRightTrivializedDerivativeInverseRateOfChange",argc,6,6,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Rotation_RPYRightTrivializedDerivativeInverseRateOfChange" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rotation_RPYRightTrivializedDerivativeInverseRateOfChange" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rotation_RPYRightTrivializedDerivativeInverseRateOfChange" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rotation_RPYRightTrivializedDerivativeInverseRateOfChange" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rotation_RPYRightTrivializedDerivativeInverseRateOfChange" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Rotation_RPYRightTrivializedDerivativeInverseRateOfChange" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  result = iDynTree::Rotation::RPYRightTrivializedDerivativeInverseRateOfChange(arg1,arg2,arg3,arg4,arg5,arg6);
  _out = SWIG_NewPointerObj((new iDynTree::Matrix3x3(static_cast< const iDynTree::Matrix3x3& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_QuaternionRightTrivializedDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Vector4 arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< iDynTree::MatrixFixSize< 4,3 > > result;
  
  if (!SWIG_check_num_args("Rotation_QuaternionRightTrivializedDerivative",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_QuaternionRightTrivializedDerivative" "', argument " "1"" of type '" "iDynTree::Vector4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_QuaternionRightTrivializedDerivative" "', argument " "1"" of type '" "iDynTree::Vector4""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::Vector4 * >(argp1));
    }
  }
  result = iDynTree::Rotation::QuaternionRightTrivializedDerivative(arg1);
  _out = SWIG_NewPointerObj((new iDynTree::MatrixFixSize< 4,3 >(static_cast< const iDynTree::MatrixFixSize< 4,3 >& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_3_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_QuaternionRightTrivializedDerivativeInverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Vector4 arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< iDynTree::MatrixFixSize< 3,4 > > result;
  
  if (!SWIG_check_num_args("Rotation_QuaternionRightTrivializedDerivativeInverse",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_QuaternionRightTrivializedDerivativeInverse" "', argument " "1"" of type '" "iDynTree::Vector4""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_QuaternionRightTrivializedDerivativeInverse" "', argument " "1"" of type '" "iDynTree::Vector4""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::Vector4 * >(argp1));
    }
  }
  result = iDynTree::Rotation::QuaternionRightTrivializedDerivativeInverse(arg1);
  _out = SWIG_NewPointerObj((new iDynTree::MatrixFixSize< 3,4 >(static_cast< const iDynTree::MatrixFixSize< 3,4 >& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_4_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_Identity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Rotation result;
  
  if (!SWIG_check_num_args("Rotation_Identity",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = iDynTree::Rotation::Identity();
  _out = SWIG_NewPointerObj((new iDynTree::Rotation(static_cast< const iDynTree::Rotation& >(result))), SWIGTYPE_p_iDynTree__Rotation, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_RotationFromQuaternion(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Vector4 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Rotation result;
  
  if (!SWIG_check_num_args("Rotation_RotationFromQuaternion",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_RotationFromQuaternion" "', argument " "1"" of type '" "iDynTree::Vector4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_RotationFromQuaternion" "', argument " "1"" of type '" "iDynTree::Vector4 const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Vector4 * >(argp1);
  result = iDynTree::Rotation::RotationFromQuaternion((iDynTree::VectorFixSize< 4 > const &)*arg1);
  _out = SWIG_NewPointerObj((new iDynTree::Rotation(static_cast< const iDynTree::Rotation& >(result))), SWIGTYPE_p_iDynTree__Rotation, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_leftJacobian(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AngularMotionVector3 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix3x3 result;
  
  if (!SWIG_check_num_args("Rotation_leftJacobian",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_leftJacobian" "', argument " "1"" of type '" "iDynTree::AngularMotionVector3 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_leftJacobian" "', argument " "1"" of type '" "iDynTree::AngularMotionVector3 const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AngularMotionVector3 * >(argp1);
  result = iDynTree::Rotation::leftJacobian((iDynTree::GeomVector3 const &)*arg1);
  _out = SWIG_NewPointerObj((new iDynTree::Matrix3x3(static_cast< const iDynTree::Matrix3x3& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_leftJacobianInverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AngularMotionVector3 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix3x3 result;
  
  if (!SWIG_check_num_args("Rotation_leftJacobianInverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_leftJacobianInverse" "', argument " "1"" of type '" "iDynTree::AngularMotionVector3 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rotation_leftJacobianInverse" "', argument " "1"" of type '" "iDynTree::AngularMotionVector3 const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AngularMotionVector3 * >(argp1);
  result = iDynTree::Rotation::leftJacobianInverse((iDynTree::GeomVector3 const &)*arg1);
  _out = SWIG_NewPointerObj((new iDynTree::Matrix3x3(static_cast< const iDynTree::Matrix3x3& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Rotation_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_toString" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  result = ((iDynTree::Rotation const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Rotation_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Rotation_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rotation_display" "', argument " "1"" of type '" "iDynTree::Rotation const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  result = ((iDynTree::Rotation const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Rotation(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = (iDynTree::Rotation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Rotation",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Rotation, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rotation" "', argument " "1"" of type '" "iDynTree::Rotation *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Transform__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Transform *result = 0 ;
  
  if (!SWIG_check_num_args("new_Transform",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Transform *)new iDynTree::Transform();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Transform, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Transform__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Rotation *arg1 = 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Transform *result = 0 ;
  
  if (!SWIG_check_num_args("new_Transform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Transform" "', argument " "1"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Transform" "', argument " "1"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Rotation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Transform" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Transform" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = (iDynTree::Transform *)new iDynTree::Transform((iDynTree::Rotation const &)*arg1,(iDynTree::Position const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Transform, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Transform__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Matrix4x4 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform *result = 0 ;
  
  if (!SWIG_check_num_args("new_Transform",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Transform" "', argument " "1"" of type '" "iDynTree::Matrix4x4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Transform" "', argument " "1"" of type '" "iDynTree::Matrix4x4 const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Matrix4x4 * >(argp1);
  result = (iDynTree::Transform *)new iDynTree::Transform((iDynTree::Matrix4x4 const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Transform, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Transform__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform *result = 0 ;
  
  if (!SWIG_check_num_args("new_Transform",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Transform" "', argument " "1"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Transform" "', argument " "1"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  result = (iDynTree::Transform *)new iDynTree::Transform((iDynTree::Transform const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Transform, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Transform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Transform__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Transform__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Transform__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Transform__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Transform'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Transform::Transform()\n"
    "    iDynTree::Transform::Transform(iDynTree::Rotation const &,iDynTree::Position const &)\n"
    "    iDynTree::Transform::Transform(iDynTree::Matrix4x4 const &)\n"
    "    iDynTree::Transform::Transform(iDynTree::Transform const &)\n");
  return 1;
}


int _wrap_Transform_fromHomogeneousTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::Matrix4x4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Transform_fromHomogeneousTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_fromHomogeneousTransform" "', argument " "1"" of type '" "iDynTree::Transform *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_fromHomogeneousTransform" "', argument " "2"" of type '" "iDynTree::Matrix4x4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_fromHomogeneousTransform" "', argument " "2"" of type '" "iDynTree::Matrix4x4 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Matrix4x4 * >(argp2);
  (arg1)->fromHomogeneousTransform((iDynTree::Matrix4x4 const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_getRotation(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Rotation *result = 0 ;
  
  if (!SWIG_check_num_args("Transform_getRotation",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_getRotation" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  result = (iDynTree::Rotation *) &((iDynTree::Transform const *)arg1)->getRotation();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Rotation, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_getPosition(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("Transform_getPosition",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_getPosition" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  result = (iDynTree::Position *) &((iDynTree::Transform const *)arg1)->getPosition();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_setRotation(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::Rotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Transform_setRotation",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_setRotation" "', argument " "1"" of type '" "iDynTree::Transform *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_setRotation" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_setRotation" "', argument " "2"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Rotation * >(argp2);
  (arg1)->setRotation((iDynTree::Rotation const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_setPosition(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Transform_setPosition",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_setPosition" "', argument " "1"" of type '" "iDynTree::Transform *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_setPosition" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_setPosition" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  (arg1)->setPosition((iDynTree::Position const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_compose(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("Transform_compose",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_compose" "', argument " "1"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_compose" "', argument " "1"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_compose" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_compose" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  result = iDynTree::Transform::compose((iDynTree::Transform const &)*arg1,(iDynTree::Transform const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_inverse2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("Transform_inverse2",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_inverse2" "', argument " "1"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_inverse2" "', argument " "1"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  result = iDynTree::Transform::inverse2((iDynTree::Transform const &)*arg1);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_mtimes__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("Transform_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_mtimes" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  result = ((iDynTree::Transform const *)arg1)->operator *((iDynTree::Transform const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_inverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("Transform_inverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_inverse" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  result = ((iDynTree::Transform const *)arg1)->inverse();
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_mtimes__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Position result;
  
  if (!SWIG_check_num_args("Transform_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_mtimes" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = ((iDynTree::Transform const *)arg1)->operator *((iDynTree::Position const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_mtimes__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::Wrench *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Wrench result;
  
  if (!SWIG_check_num_args("Transform_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_mtimes" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Wrench * >(argp2);
  result = ((iDynTree::Transform const *)arg1)->operator *((iDynTree::Wrench const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Wrench(static_cast< const iDynTree::Wrench& >(result))), SWIGTYPE_p_iDynTree__Wrench, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_mtimes__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::Twist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("Transform_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_mtimes" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Twist * >(argp2);
  result = ((iDynTree::Transform const *)arg1)->operator *((iDynTree::Twist const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_mtimes__SWIG_4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::SpatialMomentum *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMomentum result;
  
  if (!SWIG_check_num_args("Transform_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_mtimes" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMomentum,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialMomentum const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp2);
  result = ((iDynTree::Transform const *)arg1)->operator *((iDynTree::SpatialMomentum const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMomentum(static_cast< const iDynTree::SpatialMomentum& >(result))), SWIGTYPE_p_iDynTree__SpatialMomentum, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_mtimes__SWIG_5(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::SpatialAcc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc result;
  
  if (!SWIG_check_num_args("Transform_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_mtimes" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialAcc * >(argp2);
  result = ((iDynTree::Transform const *)arg1)->operator *((iDynTree::SpatialAcc const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialAcc(static_cast< const iDynTree::SpatialAcc& >(result))), SWIGTYPE_p_iDynTree__SpatialAcc, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_mtimes__SWIG_6(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::SpatialMotionVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("Transform_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_mtimes" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialMotionVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp2);
  result = ((iDynTree::Transform const *)arg1)->operator *((iDynTree::SpatialMotionVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_mtimes__SWIG_7(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::SpatialForceVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("Transform_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_mtimes" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialForceVector const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp2);
  result = ((iDynTree::Transform const *)arg1)->operator *((iDynTree::SpatialForceVector const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_mtimes__SWIG_8(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::SpatialInertia *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertia result;
  
  if (!SWIG_check_num_args("Transform_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_mtimes" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialInertia,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialInertia const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::SpatialInertia const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialInertia * >(argp2);
  result = ((iDynTree::Transform const *)arg1)->operator *((iDynTree::SpatialInertia const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialInertia(static_cast< const iDynTree::SpatialInertia& >(result))), SWIGTYPE_p_iDynTree__SpatialInertia, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_mtimes__SWIG_9(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::ArticulatedBodyInertia *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::ArticulatedBodyInertia result;
  
  if (!SWIG_check_num_args("Transform_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_mtimes" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::ArticulatedBodyInertia const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::ArticulatedBodyInertia const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp2);
  result = ((iDynTree::Transform const *)arg1)->operator *((iDynTree::ArticulatedBodyInertia const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::ArticulatedBodyInertia(static_cast< const iDynTree::ArticulatedBodyInertia& >(result))), SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_mtimes__SWIG_10(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::Direction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Direction result;
  
  if (!SWIG_check_num_args("Transform_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_mtimes" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Direction * >(argp2);
  result = ((iDynTree::Transform const *)arg1)->operator *((iDynTree::Direction const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Direction(static_cast< const iDynTree::Direction& >(result))), SWIGTYPE_p_iDynTree__Direction, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_mtimes__SWIG_11(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  iDynTree::Axis *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Axis result;
  
  if (!SWIG_check_num_args("Transform_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_mtimes" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Axis,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transform_mtimes" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Axis * >(argp2);
  result = ((iDynTree::Transform const *)arg1)->operator *((iDynTree::Axis const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Axis(static_cast< const iDynTree::Axis& >(result))), SWIGTYPE_p_iDynTree__Axis, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_mtimes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Transform_mtimes__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Transform_mtimes__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Wrench, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Transform_mtimes__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Twist, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Transform_mtimes__SWIG_3(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMomentum, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Transform_mtimes__SWIG_4(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialAcc, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Transform_mtimes__SWIG_5(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionVector, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Transform_mtimes__SWIG_6(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialForceVector, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Transform_mtimes__SWIG_7(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpatialInertia, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Transform_mtimes__SWIG_8(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Transform_mtimes__SWIG_9(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Transform_mtimes__SWIG_10(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Transform_mtimes__SWIG_11(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Transform_mtimes'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Transform::operator *(iDynTree::Transform const &) const\n"
    "    iDynTree::Transform::operator *(iDynTree::Position const &) const\n"
    "    iDynTree::Transform::operator *(iDynTree::Wrench const &) const\n"
    "    iDynTree::Transform::operator *(iDynTree::Twist const &) const\n"
    "    iDynTree::Transform::operator *(iDynTree::SpatialMomentum const &) const\n"
    "    iDynTree::Transform::operator *(iDynTree::SpatialAcc const &) const\n"
    "    iDynTree::Transform::operator *(iDynTree::SpatialMotionVector const &) const\n"
    "    iDynTree::Transform::operator *(iDynTree::SpatialForceVector const &) const\n"
    "    iDynTree::Transform::operator *(iDynTree::SpatialInertia const &) const\n"
    "    iDynTree::Transform::operator *(iDynTree::ArticulatedBodyInertia const &) const\n"
    "    iDynTree::Transform::operator *(iDynTree::Direction const &) const\n"
    "    iDynTree::Transform::operator *(iDynTree::Axis const &) const\n");
  return 1;
}


int _wrap_Transform_Identity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("Transform_Identity",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = iDynTree::Transform::Identity();
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_asHomogeneousTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix4x4 result;
  
  if (!SWIG_check_num_args("Transform_asHomogeneousTransform",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_asHomogeneousTransform" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  result = ((iDynTree::Transform const *)arg1)->asHomogeneousTransform();
  _out = SWIG_NewPointerObj((new iDynTree::Matrix4x4(static_cast< const iDynTree::Matrix4x4& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_asAdjointTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix6x6 result;
  
  if (!SWIG_check_num_args("Transform_asAdjointTransform",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_asAdjointTransform" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  result = ((iDynTree::Transform const *)arg1)->asAdjointTransform();
  _out = SWIG_NewPointerObj((new iDynTree::Matrix6x6(static_cast< const iDynTree::Matrix6x6& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_asAdjointTransformWrench(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix6x6 result;
  
  if (!SWIG_check_num_args("Transform_asAdjointTransformWrench",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_asAdjointTransformWrench" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  result = ((iDynTree::Transform const *)arg1)->asAdjointTransformWrench();
  _out = SWIG_NewPointerObj((new iDynTree::Matrix6x6(static_cast< const iDynTree::Matrix6x6& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_log(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("Transform_log",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_log" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  result = ((iDynTree::Transform const *)arg1)->log();
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Transform_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_toString" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  result = ((iDynTree::Transform const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Transform_display(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Transform_display",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transform_display" "', argument " "1"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  result = ((iDynTree::Transform const *)arg1)->reservedToString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Transform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = (iDynTree::Transform *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Transform",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Transform" "', argument " "1"" of type '" "iDynTree::Transform *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_TransformDerivative__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::TransformDerivative *result = 0 ;
  
  if (!SWIG_check_num_args("new_TransformDerivative",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::TransformDerivative *)new iDynTree::TransformDerivative();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__TransformDerivative, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_TransformDerivative__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Matrix3x3 *arg1 = 0 ;
  iDynTree::Vector3 *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::TransformDerivative *result = 0 ;
  
  if (!SWIG_check_num_args("new_TransformDerivative",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransformDerivative" "', argument " "1"" of type '" "iDynTree::Matrix3x3 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TransformDerivative" "', argument " "1"" of type '" "iDynTree::Matrix3x3 const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Matrix3x3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TransformDerivative" "', argument " "2"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TransformDerivative" "', argument " "2"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector3 * >(argp2);
  result = (iDynTree::TransformDerivative *)new iDynTree::TransformDerivative((iDynTree::Matrix3x3 const &)*arg1,(iDynTree::Vector3 const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__TransformDerivative, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_TransformDerivative__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::TransformDerivative *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::TransformDerivative *result = 0 ;
  
  if (!SWIG_check_num_args("new_TransformDerivative",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__TransformDerivative,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransformDerivative" "', argument " "1"" of type '" "iDynTree::TransformDerivative const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_TransformDerivative" "', argument " "1"" of type '" "iDynTree::TransformDerivative const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::TransformDerivative * >(argp1);
  result = (iDynTree::TransformDerivative *)new iDynTree::TransformDerivative((iDynTree::TransformDerivative const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__TransformDerivative, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_TransformDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_TransformDerivative__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__TransformDerivative, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TransformDerivative__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TransformDerivative__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_TransformDerivative'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::TransformDerivative::TransformDerivative()\n"
    "    iDynTree::TransformDerivative::TransformDerivative(iDynTree::Matrix3x3 const &,iDynTree::Vector3 const &)\n"
    "    iDynTree::TransformDerivative::TransformDerivative(iDynTree::TransformDerivative const &)\n");
  return 1;
}


int _wrap_delete_TransformDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::TransformDerivative *arg1 = (iDynTree::TransformDerivative *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_TransformDerivative",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__TransformDerivative, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransformDerivative" "', argument " "1"" of type '" "iDynTree::TransformDerivative *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::TransformDerivative * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_TransformDerivative_getRotationDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::TransformDerivative *arg1 = (iDynTree::TransformDerivative *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix3x3 *result = 0 ;
  
  if (!SWIG_check_num_args("TransformDerivative_getRotationDerivative",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__TransformDerivative, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformDerivative_getRotationDerivative" "', argument " "1"" of type '" "iDynTree::TransformDerivative const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::TransformDerivative * >(argp1);
  result = (iDynTree::Matrix3x3 *) &((iDynTree::TransformDerivative const *)arg1)->getRotationDerivative();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_TransformDerivative_getPositionDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::TransformDerivative *arg1 = (iDynTree::TransformDerivative *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Vector3 *result = 0 ;
  
  if (!SWIG_check_num_args("TransformDerivative_getPositionDerivative",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__TransformDerivative, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformDerivative_getPositionDerivative" "', argument " "1"" of type '" "iDynTree::TransformDerivative const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::TransformDerivative * >(argp1);
  result = (iDynTree::Vector3 *) &((iDynTree::TransformDerivative const *)arg1)->getPositionDerivative();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_TransformDerivative_setRotationDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::TransformDerivative *arg1 = (iDynTree::TransformDerivative *) 0 ;
  iDynTree::Matrix3x3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("TransformDerivative_setRotationDerivative",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__TransformDerivative, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformDerivative_setRotationDerivative" "', argument " "1"" of type '" "iDynTree::TransformDerivative *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::TransformDerivative * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixFixSizeT_3_3_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransformDerivative_setRotationDerivative" "', argument " "2"" of type '" "iDynTree::Matrix3x3 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransformDerivative_setRotationDerivative" "', argument " "2"" of type '" "iDynTree::Matrix3x3 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Matrix3x3 * >(argp2);
  (arg1)->setRotationDerivative((iDynTree::Matrix3x3 const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_TransformDerivative_setPositionDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::TransformDerivative *arg1 = (iDynTree::TransformDerivative *) 0 ;
  iDynTree::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("TransformDerivative_setPositionDerivative",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__TransformDerivative, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformDerivative_setPositionDerivative" "', argument " "1"" of type '" "iDynTree::TransformDerivative *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::TransformDerivative * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransformDerivative_setPositionDerivative" "', argument " "2"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransformDerivative_setPositionDerivative" "', argument " "2"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector3 * >(argp2);
  (arg1)->setPositionDerivative((iDynTree::Vector3 const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_TransformDerivative_Zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::TransformDerivative result;
  
  if (!SWIG_check_num_args("TransformDerivative_Zero",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = iDynTree::TransformDerivative::Zero();
  _out = SWIG_NewPointerObj((new iDynTree::TransformDerivative(static_cast< const iDynTree::TransformDerivative& >(result))), SWIGTYPE_p_iDynTree__TransformDerivative, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_TransformDerivative_asHomogeneousTransformDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::TransformDerivative *arg1 = (iDynTree::TransformDerivative *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix4x4 result;
  
  if (!SWIG_check_num_args("TransformDerivative_asHomogeneousTransformDerivative",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__TransformDerivative, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformDerivative_asHomogeneousTransformDerivative" "', argument " "1"" of type '" "iDynTree::TransformDerivative const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::TransformDerivative * >(argp1);
  result = ((iDynTree::TransformDerivative const *)arg1)->asHomogeneousTransformDerivative();
  _out = SWIG_NewPointerObj((new iDynTree::Matrix4x4(static_cast< const iDynTree::Matrix4x4& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_TransformDerivative_asAdjointTransformDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::TransformDerivative *arg1 = (iDynTree::TransformDerivative *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Matrix6x6 result;
  
  if (!SWIG_check_num_args("TransformDerivative_asAdjointTransformDerivative",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__TransformDerivative, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformDerivative_asAdjointTransformDerivative" "', argument " "1"" of type '" "iDynTree::TransformDerivative const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::TransformDerivative * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransformDerivative_asAdjointTransformDerivative" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransformDerivative_asAdjointTransformDerivative" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  result = ((iDynTree::TransformDerivative const *)arg1)->asAdjointTransformDerivative((iDynTree::Transform const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Matrix6x6(static_cast< const iDynTree::Matrix6x6& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_TransformDerivative_asAdjointTransformWrenchDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::TransformDerivative *arg1 = (iDynTree::TransformDerivative *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Matrix6x6 result;
  
  if (!SWIG_check_num_args("TransformDerivative_asAdjointTransformWrenchDerivative",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__TransformDerivative, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformDerivative_asAdjointTransformWrenchDerivative" "', argument " "1"" of type '" "iDynTree::TransformDerivative const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::TransformDerivative * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransformDerivative_asAdjointTransformWrenchDerivative" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransformDerivative_asAdjointTransformWrenchDerivative" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  result = ((iDynTree::TransformDerivative const *)arg1)->asAdjointTransformWrenchDerivative((iDynTree::Transform const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Matrix6x6(static_cast< const iDynTree::Matrix6x6& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_TransformDerivative_mtimes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::TransformDerivative *arg1 = (iDynTree::TransformDerivative *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::TransformDerivative result;
  
  if (!SWIG_check_num_args("TransformDerivative_mtimes",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__TransformDerivative, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformDerivative_mtimes" "', argument " "1"" of type '" "iDynTree::TransformDerivative const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::TransformDerivative * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransformDerivative_mtimes" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransformDerivative_mtimes" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  result = ((iDynTree::TransformDerivative const *)arg1)->operator *((iDynTree::Transform const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::TransformDerivative(static_cast< const iDynTree::TransformDerivative& >(result))), SWIGTYPE_p_iDynTree__TransformDerivative, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_TransformDerivative_derivativeOfInverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::TransformDerivative *arg1 = (iDynTree::TransformDerivative *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::TransformDerivative result;
  
  if (!SWIG_check_num_args("TransformDerivative_derivativeOfInverse",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__TransformDerivative, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformDerivative_derivativeOfInverse" "', argument " "1"" of type '" "iDynTree::TransformDerivative const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::TransformDerivative * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransformDerivative_derivativeOfInverse" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransformDerivative_derivativeOfInverse" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  result = ((iDynTree::TransformDerivative const *)arg1)->derivativeOfInverse((iDynTree::Transform const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::TransformDerivative(static_cast< const iDynTree::TransformDerivative& >(result))), SWIGTYPE_p_iDynTree__TransformDerivative, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_TransformDerivative_transform__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::TransformDerivative *arg1 = (iDynTree::TransformDerivative *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  iDynTree::ArticulatedBodyInertia *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::ArticulatedBodyInertia result;
  
  if (!SWIG_check_num_args("TransformDerivative_transform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__TransformDerivative, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformDerivative_transform" "', argument " "1"" of type '" "iDynTree::TransformDerivative *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::TransformDerivative * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransformDerivative_transform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransformDerivative_transform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransformDerivative_transform" "', argument " "3"" of type '" "iDynTree::ArticulatedBodyInertia &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransformDerivative_transform" "', argument " "3"" of type '" "iDynTree::ArticulatedBodyInertia &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::ArticulatedBodyInertia * >(argp3);
  result = (arg1)->transform((iDynTree::Transform const &)*arg2,*arg3);
  _out = SWIG_NewPointerObj((new iDynTree::ArticulatedBodyInertia(static_cast< const iDynTree::ArticulatedBodyInertia& >(result))), SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_TransformDerivative_transform__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::TransformDerivative *arg1 = (iDynTree::TransformDerivative *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  iDynTree::SpatialForceVector *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector result;
  
  if (!SWIG_check_num_args("TransformDerivative_transform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__TransformDerivative, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformDerivative_transform" "', argument " "1"" of type '" "iDynTree::TransformDerivative *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::TransformDerivative * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransformDerivative_transform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransformDerivative_transform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpatialForceVector,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransformDerivative_transform" "', argument " "3"" of type '" "iDynTree::SpatialForceVector &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransformDerivative_transform" "', argument " "3"" of type '" "iDynTree::SpatialForceVector &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::SpatialForceVector * >(argp3);
  result = (arg1)->transform((iDynTree::Transform const &)*arg2,*arg3);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialForceVector(static_cast< const iDynTree::SpatialForceVector& >(result))), SWIGTYPE_p_iDynTree__SpatialForceVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_TransformDerivative_transform__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::TransformDerivative *arg1 = (iDynTree::TransformDerivative *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  iDynTree::SpatialMotionVector *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("TransformDerivative_transform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__TransformDerivative, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformDerivative_transform" "', argument " "1"" of type '" "iDynTree::TransformDerivative *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::TransformDerivative * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransformDerivative_transform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransformDerivative_transform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpatialMotionVector,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransformDerivative_transform" "', argument " "3"" of type '" "iDynTree::SpatialMotionVector &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransformDerivative_transform" "', argument " "3"" of type '" "iDynTree::SpatialMotionVector &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::SpatialMotionVector * >(argp3);
  result = (arg1)->transform((iDynTree::Transform const &)*arg2,*arg3);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_TransformDerivative_transform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__TransformDerivative, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TransformDerivative_transform__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__TransformDerivative, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SpatialForceVector, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TransformDerivative_transform__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__TransformDerivative, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SpatialMotionVector, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TransformDerivative_transform__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'TransformDerivative_transform'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::TransformDerivative::transform(iDynTree::Transform const &,iDynTree::ArticulatedBodyInertia &)\n"
    "    iDynTree::TransformDerivative::transform(iDynTree::Transform const &,iDynTree::SpatialForceVector &)\n"
    "    iDynTree::TransformDerivative::transform(iDynTree::Transform const &,iDynTree::SpatialMotionVector &)\n");
  return 1;
}


SWIGINTERN int _wrap_dynamic_extent_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  resv[0] = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(iDynTree::dynamic_extent));
  return 0;
}


int _wrap_DynamicSpan_extent_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Span< double,-1 >::index_type result;
  
  if (!SWIG_check_num_args("DynamicSpan_extent_get",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Span< double,-1 >::index_type)iDynTree::Span< double,-1 >::extent;
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DynamicSpan__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 >::pointer arg1 = (iDynTree::Span< double,-1 >::pointer) 0 ;
  iDynTree::Span< double,-1 >::index_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Span< double,-1 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_DynamicSpan",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DynamicSpan" "', argument " "1"" of type '" "iDynTree::Span< double,-1 >::pointer""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 >::pointer >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DynamicSpan" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >::index_type""'");
  } 
  arg2 = static_cast< iDynTree::Span< double,-1 >::index_type >(val2);
  result = (iDynTree::Span< double,-1 > *)new iDynTree::Span< double,-1 >(arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpanT_double__1_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DynamicSpan__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 >::pointer arg1 = (iDynTree::Span< double,-1 >::pointer) 0 ;
  iDynTree::Span< double,-1 >::pointer arg2 = (iDynTree::Span< double,-1 >::pointer) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Span< double,-1 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_DynamicSpan",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DynamicSpan" "', argument " "1"" of type '" "iDynTree::Span< double,-1 >::pointer""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 >::pointer >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DynamicSpan" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >::pointer""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 >::pointer >(argp2);
  result = (iDynTree::Span< double,-1 > *)new iDynTree::Span< double,-1 >(arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpanT_double__1_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DynamicSpan__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Span< double,-1 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_DynamicSpan",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DynamicSpan" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DynamicSpan" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  result = (iDynTree::Span< double,-1 > *)new iDynTree::Span< double,-1 >((iDynTree::Span< double,-1 > const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpanT_double__1_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DynamicSpan(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DynamicSpan__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DynamicSpan__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DynamicSpan__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_DynamicSpan'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Span< double,-1 >::Span(iDynTree::Span< double,-1 >::pointer,iDynTree::Span< double,-1 >::index_type)\n"
    "    iDynTree::Span< double,-1 >::Span(iDynTree::Span< double,-1 >::pointer,iDynTree::Span< double,-1 >::pointer)\n"
    "    iDynTree::Span< double,-1 >::Span(iDynTree::Span< double,-1 > const &)\n");
  return 1;
}


int _wrap_delete_DynamicSpan(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_DynamicSpan",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DynamicSpan" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_first(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  iDynTree::Span< double,-1 >::index_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  SwigValueWrapper< iDynTree::Span< double,-1 > > result;
  
  if (!SWIG_check_num_args("DynamicSpan_first",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_first" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DynamicSpan_first" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >::index_type""'");
  } 
  arg2 = static_cast< iDynTree::Span< double,-1 >::index_type >(val2);
  result = ((iDynTree::Span< double,-1 > const *)arg1)->first(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Span< iDynTree::Span< double,-1 >::element_type,-1 >(static_cast< const iDynTree::Span< iDynTree::Span< double,-1 >::element_type,-1 >& >(result))), SWIGTYPE_p_iDynTree__SpanT_double__1_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_last(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  iDynTree::Span< double,-1 >::index_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  SwigValueWrapper< iDynTree::Span< double,-1 > > result;
  
  if (!SWIG_check_num_args("DynamicSpan_last",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_last" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DynamicSpan_last" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >::index_type""'");
  } 
  arg2 = static_cast< iDynTree::Span< double,-1 >::index_type >(val2);
  result = ((iDynTree::Span< double,-1 > const *)arg1)->last(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Span< iDynTree::Span< double,-1 >::element_type,-1 >(static_cast< const iDynTree::Span< iDynTree::Span< double,-1 >::element_type,-1 >& >(result))), SWIGTYPE_p_iDynTree__SpanT_double__1_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_subspan__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  iDynTree::Span< double,-1 >::index_type arg2 ;
  iDynTree::Span< double,-1 >::index_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  SwigValueWrapper< iDynTree::Span< double,-1 > > result;
  
  if (!SWIG_check_num_args("DynamicSpan_subspan",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_subspan" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DynamicSpan_subspan" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >::index_type""'");
  } 
  arg2 = static_cast< iDynTree::Span< double,-1 >::index_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DynamicSpan_subspan" "', argument " "3"" of type '" "iDynTree::Span< double,-1 >::index_type""'");
  } 
  arg3 = static_cast< iDynTree::Span< double,-1 >::index_type >(val3);
  result = ((iDynTree::Span< double,-1 > const *)arg1)->subspan(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Span< iDynTree::Span< double,-1 >::element_type,-1 >(static_cast< const iDynTree::Span< iDynTree::Span< double,-1 >::element_type,-1 >& >(result))), SWIGTYPE_p_iDynTree__SpanT_double__1_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_subspan__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  iDynTree::Span< double,-1 >::index_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  SwigValueWrapper< iDynTree::Span< double,-1 > > result;
  
  if (!SWIG_check_num_args("DynamicSpan_subspan",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_subspan" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DynamicSpan_subspan" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >::index_type""'");
  } 
  arg2 = static_cast< iDynTree::Span< double,-1 >::index_type >(val2);
  result = ((iDynTree::Span< double,-1 > const *)arg1)->subspan(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Span< iDynTree::Span< double,-1 >::element_type,-1 >(static_cast< const iDynTree::Span< iDynTree::Span< double,-1 >::element_type,-1 >& >(result))), SWIGTYPE_p_iDynTree__SpanT_double__1_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_subspan(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DynamicSpan_subspan__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DynamicSpan_subspan__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'DynamicSpan_subspan'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Span< double,-1 >::subspan(iDynTree::Span< double,-1 >::index_type,iDynTree::Span< double,-1 >::index_type) const\n"
    "    iDynTree::Span< double,-1 >::subspan(iDynTree::Span< double,-1 >::index_type) const\n");
  return 1;
}


int _wrap_DynamicSpan_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Span< double,-1 >::index_type result;
  
  if (!SWIG_check_num_args("DynamicSpan_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_size" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  result = ((iDynTree::Span< double,-1 > const *)arg1)->size();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_size_bytes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Span< double,-1 >::index_type result;
  
  if (!SWIG_check_num_args("DynamicSpan_size_bytes",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_size_bytes" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  result = ((iDynTree::Span< double,-1 > const *)arg1)->size_bytes();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_empty(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DynamicSpan_empty",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_empty" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  result = (bool)((iDynTree::Span< double,-1 > const *)arg1)->empty();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_brace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  iDynTree::Span< double,-1 >::index_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Span< double,-1 >::element_type *result = 0 ;
  
  if (!SWIG_check_num_args("DynamicSpan_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_brace" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DynamicSpan_brace" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >::index_type""'");
  } 
  arg2 = static_cast< iDynTree::Span< double,-1 >::index_type >(val2);
  result = (iDynTree::Span< double,-1 >::element_type *) &((iDynTree::Span< double,-1 > const *)arg1)->operator [](arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_getVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  iDynTree::Span< double,-1 >::index_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Span< double,-1 >::element_type *result = 0 ;
  
  if (!SWIG_check_num_args("DynamicSpan_getVal",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_getVal" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DynamicSpan_getVal" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >::index_type""'");
  } 
  arg2 = static_cast< iDynTree::Span< double,-1 >::index_type >(val2);
  result = (iDynTree::Span< double,-1 >::element_type *) &((iDynTree::Span< double,-1 > const *)arg1)->getVal(arg2);
  _out = SWIG_From_double(static_cast< double >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_setVal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  iDynTree::Span< double,-1 >::index_type arg2 ;
  iDynTree::Span< double,-1 >::element_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  double temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DynamicSpan_setVal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_setVal" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DynamicSpan_setVal" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >::index_type""'");
  } 
  arg2 = static_cast< iDynTree::Span< double,-1 >::index_type >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DynamicSpan_setVal" "', argument " "3"" of type '" "double""'");
  } 
  temp3 = static_cast< double >(val3);
  arg3 = &temp3;
  result = (bool)(arg1)->setVal(arg2,(iDynTree::Span< double,-1 >::element_type const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_at(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  iDynTree::Span< double,-1 >::index_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Span< double,-1 >::element_type *result = 0 ;
  
  if (!SWIG_check_num_args("DynamicSpan_at",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_at" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DynamicSpan_at" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >::index_type""'");
  } 
  arg2 = static_cast< iDynTree::Span< double,-1 >::index_type >(val2);
  result = (iDynTree::Span< double,-1 >::element_type *) &((iDynTree::Span< double,-1 > const *)arg1)->at(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  iDynTree::Span< double,-1 >::index_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Span< double,-1 >::element_type *result = 0 ;
  
  if (!SWIG_check_num_args("DynamicSpan_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_paren" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DynamicSpan_paren" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >::index_type""'");
  } 
  arg2 = static_cast< iDynTree::Span< double,-1 >::index_type >(val2);
  result = (iDynTree::Span< double,-1 >::element_type *) &((iDynTree::Span< double,-1 > const *)arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_begin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< iDynTree::details::span_iterator< iDynTree::Span< double,-1 >,false > > result;
  
  if (!SWIG_check_num_args("DynamicSpan_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_begin" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  result = ((iDynTree::Span< double,-1 > const *)arg1)->begin();
  _out = SWIG_NewPointerObj((new iDynTree::Span< double,-1 >::iterator(static_cast< const iDynTree::Span< double,-1 >::iterator& >(result))), SWIGTYPE_p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_end(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< iDynTree::details::span_iterator< iDynTree::Span< double,-1 >,false > > result;
  
  if (!SWIG_check_num_args("DynamicSpan_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_end" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  result = ((iDynTree::Span< double,-1 > const *)arg1)->end();
  _out = SWIG_NewPointerObj((new iDynTree::Span< double,-1 >::iterator(static_cast< const iDynTree::Span< double,-1 >::iterator& >(result))), SWIGTYPE_p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_cbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< iDynTree::details::span_iterator< iDynTree::Span< double,-1 >,true > > result;
  
  if (!SWIG_check_num_args("DynamicSpan_cbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_cbegin" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  result = ((iDynTree::Span< double,-1 > const *)arg1)->cbegin();
  _out = SWIG_NewPointerObj((new iDynTree::Span< double,-1 >::const_iterator(static_cast< const iDynTree::Span< double,-1 >::const_iterator& >(result))), SWIGTYPE_p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_cend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< iDynTree::details::span_iterator< iDynTree::Span< double,-1 >,true > > result;
  
  if (!SWIG_check_num_args("DynamicSpan_cend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_cend" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  result = ((iDynTree::Span< double,-1 > const *)arg1)->cend();
  _out = SWIG_NewPointerObj((new iDynTree::Span< double,-1 >::const_iterator(static_cast< const iDynTree::Span< double,-1 >::const_iterator& >(result))), SWIGTYPE_p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_rbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Span< double,-1 >::reverse_iterator result;
  
  if (!SWIG_check_num_args("DynamicSpan_rbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_rbegin" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  result = ((iDynTree::Span< double,-1 > const *)arg1)->rbegin();
  _out = SWIG_NewPointerObj((new iDynTree::Span< double,-1 >::reverse_iterator(static_cast< const iDynTree::Span< double,-1 >::reverse_iterator& >(result))), SWIGTYPE_p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_rend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Span< double,-1 >::reverse_iterator result;
  
  if (!SWIG_check_num_args("DynamicSpan_rend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_rend" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  result = ((iDynTree::Span< double,-1 > const *)arg1)->rend();
  _out = SWIG_NewPointerObj((new iDynTree::Span< double,-1 >::reverse_iterator(static_cast< const iDynTree::Span< double,-1 >::reverse_iterator& >(result))), SWIGTYPE_p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_crbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Span< double,-1 >::const_reverse_iterator result;
  
  if (!SWIG_check_num_args("DynamicSpan_crbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_crbegin" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  result = ((iDynTree::Span< double,-1 > const *)arg1)->crbegin();
  _out = SWIG_NewPointerObj((new iDynTree::Span< double,-1 >::const_reverse_iterator(static_cast< const iDynTree::Span< double,-1 >::const_reverse_iterator& >(result))), SWIGTYPE_p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicSpan_crend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Span< double,-1 > *arg1 = (iDynTree::Span< double,-1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Span< double,-1 >::const_reverse_iterator result;
  
  if (!SWIG_check_num_args("DynamicSpan_crend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicSpan_crend" "', argument " "1"" of type '" "iDynTree::Span< double,-1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp1);
  result = ((iDynTree::Span< double,-1 > const *)arg1)->crend();
  _out = SWIG_NewPointerObj((new iDynTree::Span< double,-1 >::const_reverse_iterator(static_cast< const iDynTree::Span< double,-1 >::const_reverse_iterator& >(result))), SWIGTYPE_p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DynamicMatrixView__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::MatrixView< double > *result = 0 ;
  
  if (!SWIG_check_num_args("new_DynamicMatrixView",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::MatrixView< double > *)new iDynTree::MatrixView< double >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DynamicMatrixView__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixView< double > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixView< double > *result = 0 ;
  
  if (!SWIG_check_num_args("new_DynamicMatrixView",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DynamicMatrixView" "', argument " "1"" of type '" "iDynTree::MatrixView< double > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DynamicMatrixView" "', argument " "1"" of type '" "iDynTree::MatrixView< double > const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixView< double > * >(argp1);
  result = (iDynTree::MatrixView< double > *)new iDynTree::MatrixView< double >((iDynTree::MatrixView< double > const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DynamicMatrixView__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixView< double >::pointer arg1 = (iDynTree::MatrixView< double >::pointer) 0 ;
  iDynTree::MatrixView< double >::index_type arg2 ;
  iDynTree::MatrixView< double >::index_type arg3 ;
  iDynTree::MatrixStorageOrdering *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 ;
  iDynTree::MatrixStorageOrdering temp4 ;
  mxArray * _out;
  iDynTree::MatrixView< double > *result = 0 ;
  
  if (!SWIG_check_num_args("new_DynamicMatrixView",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DynamicMatrixView" "', argument " "1"" of type '" "iDynTree::MatrixView< double >::pointer""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixView< double >::pointer >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DynamicMatrixView" "', argument " "2"" of type '" "iDynTree::MatrixView< double >::index_type""'");
  } 
  arg2 = static_cast< iDynTree::MatrixView< double >::index_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DynamicMatrixView" "', argument " "3"" of type '" "iDynTree::MatrixView< double >::index_type""'");
  } 
  arg3 = static_cast< iDynTree::MatrixView< double >::index_type >(val3);
  ecode4 = SWIG_AsVal_int (argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DynamicMatrixView" "', argument " "4"" of type '" "iDynTree::MatrixStorageOrdering const &""'");
  } else {
    temp4 = static_cast< iDynTree::MatrixStorageOrdering >(val4);
    arg4 = &temp4;
  }
  result = (iDynTree::MatrixView< double > *)new iDynTree::MatrixView< double >(arg1,arg2,arg3,(iDynTree::MatrixStorageOrdering const &)*arg4);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DynamicMatrixView__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixView< double >::pointer arg1 = (iDynTree::MatrixView< double >::pointer) 0 ;
  iDynTree::MatrixView< double >::index_type arg2 ;
  iDynTree::MatrixView< double >::index_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::MatrixView< double > *result = 0 ;
  
  if (!SWIG_check_num_args("new_DynamicMatrixView",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DynamicMatrixView" "', argument " "1"" of type '" "iDynTree::MatrixView< double >::pointer""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixView< double >::pointer >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DynamicMatrixView" "', argument " "2"" of type '" "iDynTree::MatrixView< double >::index_type""'");
  } 
  arg2 = static_cast< iDynTree::MatrixView< double >::index_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DynamicMatrixView" "', argument " "3"" of type '" "iDynTree::MatrixView< double >::index_type""'");
  } 
  arg3 = static_cast< iDynTree::MatrixView< double >::index_type >(val3);
  result = (iDynTree::MatrixView< double > *)new iDynTree::MatrixView< double >(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DynamicMatrixView(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_DynamicMatrixView__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DynamicMatrixView__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_DynamicMatrixView__SWIG_3(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_DynamicMatrixView__SWIG_2(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_DynamicMatrixView'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MatrixView< double >::MatrixView()\n"
    "    iDynTree::MatrixView< double >::MatrixView(iDynTree::MatrixView< double > const &)\n"
    "    iDynTree::MatrixView< double >::MatrixView(iDynTree::MatrixView< double >::pointer,iDynTree::MatrixView< double >::index_type,iDynTree::MatrixView< double >::index_type,iDynTree::MatrixStorageOrdering const &)\n"
    "    iDynTree::MatrixView< double >::MatrixView(iDynTree::MatrixView< double >::pointer,iDynTree::MatrixView< double >::index_type,iDynTree::MatrixView< double >::index_type)\n");
  return 1;
}


int _wrap_DynamicMatrixView_storageOrder(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixView< double > *arg1 = (iDynTree::MatrixView< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixStorageOrdering *result = 0 ;
  
  if (!SWIG_check_num_args("DynamicMatrixView_storageOrder",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicMatrixView_storageOrder" "', argument " "1"" of type '" "iDynTree::MatrixView< double > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixView< double > * >(argp1);
  result = (iDynTree::MatrixStorageOrdering *) &((iDynTree::MatrixView< double > const *)arg1)->storageOrder();
  _out = SWIG_From_int(static_cast< int >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicMatrixView_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixView< double > *arg1 = (iDynTree::MatrixView< double > *) 0 ;
  iDynTree::MatrixView< double >::index_type arg2 ;
  iDynTree::MatrixView< double >::index_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::MatrixView< double >::element_type *result = 0 ;
  
  if (!SWIG_check_num_args("DynamicMatrixView_paren",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicMatrixView_paren" "', argument " "1"" of type '" "iDynTree::MatrixView< double > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixView< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DynamicMatrixView_paren" "', argument " "2"" of type '" "iDynTree::MatrixView< double >::index_type""'");
  } 
  arg2 = static_cast< iDynTree::MatrixView< double >::index_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DynamicMatrixView_paren" "', argument " "3"" of type '" "iDynTree::MatrixView< double >::index_type""'");
  } 
  arg3 = static_cast< iDynTree::MatrixView< double >::index_type >(val3);
  result = (iDynTree::MatrixView< double >::element_type *) &((iDynTree::MatrixView< double > const *)arg1)->operator ()(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicMatrixView_rows(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixView< double > *arg1 = (iDynTree::MatrixView< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixView< double >::index_type result;
  
  if (!SWIG_check_num_args("DynamicMatrixView_rows",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicMatrixView_rows" "', argument " "1"" of type '" "iDynTree::MatrixView< double > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixView< double > * >(argp1);
  result = ((iDynTree::MatrixView< double > const *)arg1)->rows();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicMatrixView_cols(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixView< double > *arg1 = (iDynTree::MatrixView< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixView< double >::index_type result;
  
  if (!SWIG_check_num_args("DynamicMatrixView_cols",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicMatrixView_cols" "', argument " "1"" of type '" "iDynTree::MatrixView< double > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixView< double > * >(argp1);
  result = ((iDynTree::MatrixView< double > const *)arg1)->cols();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DynamicMatrixView_block(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixView< double > *arg1 = (iDynTree::MatrixView< double > *) 0 ;
  iDynTree::MatrixView< double >::index_type arg2 ;
  iDynTree::MatrixView< double >::index_type arg3 ;
  iDynTree::MatrixView< double >::index_type arg4 ;
  iDynTree::MatrixView< double >::index_type arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  mxArray * _out;
  iDynTree::MatrixView< double > result;
  
  if (!SWIG_check_num_args("DynamicMatrixView_block",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DynamicMatrixView_block" "', argument " "1"" of type '" "iDynTree::MatrixView< double > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixView< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DynamicMatrixView_block" "', argument " "2"" of type '" "iDynTree::MatrixView< double >::index_type""'");
  } 
  arg2 = static_cast< iDynTree::MatrixView< double >::index_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DynamicMatrixView_block" "', argument " "3"" of type '" "iDynTree::MatrixView< double >::index_type""'");
  } 
  arg3 = static_cast< iDynTree::MatrixView< double >::index_type >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DynamicMatrixView_block" "', argument " "4"" of type '" "iDynTree::MatrixView< double >::index_type""'");
  } 
  arg4 = static_cast< iDynTree::MatrixView< double >::index_type >(val4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DynamicMatrixView_block" "', argument " "5"" of type '" "iDynTree::MatrixView< double >::index_type""'");
  } 
  arg5 = static_cast< iDynTree::MatrixView< double >::index_type >(val5);
  result = ((iDynTree::MatrixView< double > const *)arg1)->block(arg2,arg3,arg4,arg5);
  _out = SWIG_NewPointerObj((new iDynTree::MatrixView< double >(static_cast< const iDynTree::MatrixView< double >& >(result))), SWIGTYPE_p_iDynTree__MatrixViewT_double_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_DynamicMatrixView(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MatrixView< double > *arg1 = (iDynTree::MatrixView< double > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_DynamicMatrixView",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MatrixViewT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DynamicMatrixView" "', argument " "1"" of type '" "iDynTree::MatrixView< double > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MatrixView< double > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


SWIGINTERN int _wrap_LINK_INVALID_INDEX_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  resv[0] = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(iDynTree::LINK_INVALID_INDEX));
  return 0;
}


SWIGINTERN int _wrap_LINK_INVALID_INDEX_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  {
    ptrdiff_t val;
    int res = SWIG_AsVal_ptrdiff_t(argv[0], &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""iDynTree::LINK_INVALID_INDEX""' of type '""iDynTree::LinkIndex""'");
    }
    iDynTree::LINK_INVALID_INDEX = static_cast< iDynTree::LinkIndex >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN int _wrap_LINK_INVALID_NAME_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  resv[0] = SWIG_From_std_string(static_cast< std::string >(iDynTree::LINK_INVALID_NAME));
  return 0;
}


SWIGINTERN int _wrap_LINK_INVALID_NAME_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""iDynTree::LINK_INVALID_NAME""' of type '""std::string""'"); 
    }
    iDynTree::LINK_INVALID_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN int _wrap_JOINT_INVALID_INDEX_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  resv[0] = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(iDynTree::JOINT_INVALID_INDEX));
  return 0;
}


SWIGINTERN int _wrap_JOINT_INVALID_INDEX_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  {
    ptrdiff_t val;
    int res = SWIG_AsVal_ptrdiff_t(argv[0], &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""iDynTree::JOINT_INVALID_INDEX""' of type '""std::ptrdiff_t""'");
    }
    iDynTree::JOINT_INVALID_INDEX = static_cast< std::ptrdiff_t >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN int _wrap_JOINT_INVALID_NAME_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  resv[0] = SWIG_From_std_string(static_cast< std::string >(iDynTree::JOINT_INVALID_NAME));
  return 0;
}


SWIGINTERN int _wrap_JOINT_INVALID_NAME_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""iDynTree::JOINT_INVALID_NAME""' of type '""std::string""'"); 
    }
    iDynTree::JOINT_INVALID_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN int _wrap_DOF_INVALID_INDEX_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  resv[0] = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(iDynTree::DOF_INVALID_INDEX));
  return 0;
}


SWIGINTERN int _wrap_DOF_INVALID_INDEX_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  {
    ptrdiff_t val;
    int res = SWIG_AsVal_ptrdiff_t(argv[0], &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""iDynTree::DOF_INVALID_INDEX""' of type '""std::ptrdiff_t""'");
    }
    iDynTree::DOF_INVALID_INDEX = static_cast< std::ptrdiff_t >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN int _wrap_DOF_INVALID_NAME_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  resv[0] = SWIG_From_std_string(static_cast< std::string >(iDynTree::DOF_INVALID_NAME));
  return 0;
}


SWIGINTERN int _wrap_DOF_INVALID_NAME_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""iDynTree::DOF_INVALID_NAME""' of type '""std::string""'"); 
    }
    iDynTree::DOF_INVALID_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN int _wrap_FRAME_INVALID_INDEX_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  resv[0] = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(iDynTree::FRAME_INVALID_INDEX));
  return 0;
}


SWIGINTERN int _wrap_FRAME_INVALID_INDEX_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  {
    ptrdiff_t val;
    int res = SWIG_AsVal_ptrdiff_t(argv[0], &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""iDynTree::FRAME_INVALID_INDEX""' of type '""std::ptrdiff_t""'");
    }
    iDynTree::FRAME_INVALID_INDEX = static_cast< std::ptrdiff_t >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN int _wrap_FRAME_INVALID_NAME_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  resv[0] = SWIG_From_std_string(static_cast< std::string >(iDynTree::FRAME_INVALID_NAME));
  return 0;
}


SWIGINTERN int _wrap_FRAME_INVALID_NAME_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""iDynTree::FRAME_INVALID_NAME""' of type '""std::string""'"); 
    }
    iDynTree::FRAME_INVALID_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN int _wrap_TRAVERSAL_INVALID_INDEX_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  resv[0] = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(iDynTree::TRAVERSAL_INVALID_INDEX));
  return 0;
}


SWIGINTERN int _wrap_TRAVERSAL_INVALID_INDEX_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  {
    ptrdiff_t val;
    int res = SWIG_AsVal_ptrdiff_t(argv[0], &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""iDynTree::TRAVERSAL_INVALID_INDEX""' of type '""iDynTree::TraversalIndex""'");
    }
    iDynTree::TRAVERSAL_INVALID_INDEX = static_cast< iDynTree::TraversalIndex >(val);
  }
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkPositions__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::LinkPositions *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkPositions",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinkPositions" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  result = (iDynTree::LinkPositions *)new iDynTree::LinkPositions(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkPositions, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkPositions__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::LinkPositions *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkPositions",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::LinkPositions *)new iDynTree::LinkPositions();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkPositions, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkPositions__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkPositions *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkPositions",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinkPositions" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinkPositions" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::LinkPositions *)new iDynTree::LinkPositions((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkPositions, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkPositions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_LinkPositions__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LinkPositions__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LinkPositions__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_LinkPositions'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkPositions::LinkPositions(std::size_t)\n"
    "    iDynTree::LinkPositions::LinkPositions()\n"
    "    iDynTree::LinkPositions::LinkPositions(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkPositions_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkPositions *arg1 = (iDynTree::LinkPositions *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkPositions_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkPositions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkPositions_resize" "', argument " "1"" of type '" "iDynTree::LinkPositions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkPositions * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkPositions_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkPositions_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkPositions *arg1 = (iDynTree::LinkPositions *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkPositions_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkPositions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkPositions_resize" "', argument " "1"" of type '" "iDynTree::LinkPositions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkPositions * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkPositions_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkPositions_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkPositions_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkPositions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LinkPositions_resize__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkPositions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkPositions_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkPositions_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkPositions::resize(std::size_t)\n"
    "    iDynTree::LinkPositions::resize(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkPositions_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkPositions *arg1 = (iDynTree::LinkPositions *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("LinkPositions_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkPositions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkPositions_isConsistent" "', argument " "1"" of type '" "iDynTree::LinkPositions const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkPositions * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkPositions_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkPositions_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::LinkPositions const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkPositions_getNrOfLinks(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkPositions *arg1 = (iDynTree::LinkPositions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("LinkPositions_getNrOfLinks",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkPositions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkPositions_getNrOfLinks" "', argument " "1"" of type '" "iDynTree::LinkPositions const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkPositions * >(argp1);
  result = ((iDynTree::LinkPositions const *)arg1)->getNrOfLinks();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkPositions_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkPositions *arg1 = (iDynTree::LinkPositions *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Transform *result = 0 ;
  
  if (!SWIG_check_num_args("LinkPositions_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkPositions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkPositions_paren" "', argument " "1"" of type '" "iDynTree::LinkPositions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkPositions * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkPositions_paren" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::Transform *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkPositions_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkPositions *arg1 = (iDynTree::LinkPositions *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Transform *result = 0 ;
  
  if (!SWIG_check_num_args("LinkPositions_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkPositions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkPositions_paren" "', argument " "1"" of type '" "iDynTree::LinkPositions const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkPositions * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkPositions_paren" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::Transform *) &((iDynTree::LinkPositions const *)arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkPositions_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkPositions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkPositions_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkPositions, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkPositions_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkPositions_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkPositions::operator ()(iDynTree::LinkIndex const)\n"
    "    iDynTree::LinkPositions::operator ()(iDynTree::LinkIndex const) const\n");
  return 1;
}


int _wrap_LinkPositions_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkPositions *arg1 = (iDynTree::LinkPositions *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("LinkPositions_toString",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkPositions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkPositions_toString" "', argument " "1"" of type '" "iDynTree::LinkPositions const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkPositions * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkPositions_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkPositions_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = ((iDynTree::LinkPositions const *)arg1)->toString((iDynTree::Model const &)*arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_LinkPositions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkPositions *arg1 = (iDynTree::LinkPositions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_LinkPositions",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkPositions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinkPositions" "', argument " "1"" of type '" "iDynTree::LinkPositions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkPositions * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkWrenches__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::LinkWrenches *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkWrenches",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinkWrenches" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  result = (iDynTree::LinkWrenches *)new iDynTree::LinkWrenches(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkWrenches, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkWrenches__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::LinkWrenches *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkWrenches",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::LinkWrenches *)new iDynTree::LinkWrenches();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkWrenches, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkWrenches__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkWrenches *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkWrenches",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinkWrenches" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinkWrenches" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::LinkWrenches *)new iDynTree::LinkWrenches((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkWrenches, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkWrenches(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_LinkWrenches__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LinkWrenches__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LinkWrenches__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_LinkWrenches'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkWrenches::LinkWrenches(std::size_t)\n"
    "    iDynTree::LinkWrenches::LinkWrenches()\n"
    "    iDynTree::LinkWrenches::LinkWrenches(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkWrenches_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkWrenches *arg1 = (iDynTree::LinkWrenches *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkWrenches_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkWrenches_resize" "', argument " "1"" of type '" "iDynTree::LinkWrenches *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkWrenches * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkWrenches_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkWrenches_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkWrenches *arg1 = (iDynTree::LinkWrenches *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkWrenches_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkWrenches_resize" "', argument " "1"" of type '" "iDynTree::LinkWrenches *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkWrenches * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkWrenches_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkWrenches_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkWrenches_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkWrenches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LinkWrenches_resize__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkWrenches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkWrenches_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkWrenches_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkWrenches::resize(std::size_t)\n"
    "    iDynTree::LinkWrenches::resize(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkWrenches_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkWrenches *arg1 = (iDynTree::LinkWrenches *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("LinkWrenches_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkWrenches_isConsistent" "', argument " "1"" of type '" "iDynTree::LinkWrenches const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkWrenches * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkWrenches_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkWrenches_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::LinkWrenches const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkWrenches_getNrOfLinks(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkWrenches *arg1 = (iDynTree::LinkWrenches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("LinkWrenches_getNrOfLinks",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkWrenches_getNrOfLinks" "', argument " "1"" of type '" "iDynTree::LinkWrenches const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkWrenches * >(argp1);
  result = ((iDynTree::LinkWrenches const *)arg1)->getNrOfLinks();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkWrenches_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkWrenches *arg1 = (iDynTree::LinkWrenches *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Wrench *result = 0 ;
  
  if (!SWIG_check_num_args("LinkWrenches_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkWrenches_paren" "', argument " "1"" of type '" "iDynTree::LinkWrenches *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkWrenches * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkWrenches_paren" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::Wrench *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Wrench, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkWrenches_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkWrenches *arg1 = (iDynTree::LinkWrenches *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Wrench *result = 0 ;
  
  if (!SWIG_check_num_args("LinkWrenches_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkWrenches_paren" "', argument " "1"" of type '" "iDynTree::LinkWrenches const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkWrenches * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkWrenches_paren" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::Wrench *) &((iDynTree::LinkWrenches const *)arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Wrench, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkWrenches_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkWrenches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkWrenches_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkWrenches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkWrenches_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkWrenches_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkWrenches::operator ()(iDynTree::LinkIndex const)\n"
    "    iDynTree::LinkWrenches::operator ()(iDynTree::LinkIndex const) const\n");
  return 1;
}


int _wrap_LinkWrenches_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkWrenches *arg1 = (iDynTree::LinkWrenches *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("LinkWrenches_toString",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkWrenches_toString" "', argument " "1"" of type '" "iDynTree::LinkWrenches const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkWrenches * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkWrenches_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkWrenches_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = ((iDynTree::LinkWrenches const *)arg1)->toString((iDynTree::Model const &)*arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkWrenches_zero(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkWrenches *arg1 = (iDynTree::LinkWrenches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkWrenches_zero",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkWrenches_zero" "', argument " "1"" of type '" "iDynTree::LinkWrenches *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkWrenches * >(argp1);
  (arg1)->zero();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_LinkWrenches(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkWrenches *arg1 = (iDynTree::LinkWrenches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_LinkWrenches",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkWrenches, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinkWrenches" "', argument " "1"" of type '" "iDynTree::LinkWrenches *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkWrenches * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkInertias__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::LinkInertias *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkInertias",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinkInertias" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  result = (iDynTree::LinkInertias *)new iDynTree::LinkInertias(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkInertias, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkInertias__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::LinkInertias *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkInertias",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::LinkInertias *)new iDynTree::LinkInertias();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkInertias, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkInertias__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkInertias *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkInertias",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinkInertias" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinkInertias" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::LinkInertias *)new iDynTree::LinkInertias((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkInertias, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkInertias(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_LinkInertias__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LinkInertias__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LinkInertias__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_LinkInertias'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkInertias::LinkInertias(std::size_t)\n"
    "    iDynTree::LinkInertias::LinkInertias()\n"
    "    iDynTree::LinkInertias::LinkInertias(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkInertias_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkInertias *arg1 = (iDynTree::LinkInertias *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkInertias_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkInertias, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkInertias_resize" "', argument " "1"" of type '" "iDynTree::LinkInertias *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkInertias * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkInertias_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkInertias_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkInertias *arg1 = (iDynTree::LinkInertias *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkInertias_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkInertias, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkInertias_resize" "', argument " "1"" of type '" "iDynTree::LinkInertias *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkInertias * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkInertias_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkInertias_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkInertias_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkInertias, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LinkInertias_resize__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkInertias, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkInertias_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkInertias_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkInertias::resize(std::size_t)\n"
    "    iDynTree::LinkInertias::resize(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkInertias_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkInertias *arg1 = (iDynTree::LinkInertias *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("LinkInertias_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkInertias, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkInertias_isConsistent" "', argument " "1"" of type '" "iDynTree::LinkInertias const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkInertias * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkInertias_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkInertias_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::LinkInertias const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkInertias_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkInertias *arg1 = (iDynTree::LinkInertias *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertia *result = 0 ;
  
  if (!SWIG_check_num_args("LinkInertias_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkInertias, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkInertias_paren" "', argument " "1"" of type '" "iDynTree::LinkInertias *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkInertias * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkInertias_paren" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::SpatialInertia *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkInertias_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkInertias *arg1 = (iDynTree::LinkInertias *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertia *result = 0 ;
  
  if (!SWIG_check_num_args("LinkInertias_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkInertias, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkInertias_paren" "', argument " "1"" of type '" "iDynTree::LinkInertias const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkInertias * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkInertias_paren" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::SpatialInertia *) &((iDynTree::LinkInertias const *)arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkInertias_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkInertias, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkInertias_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkInertias, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkInertias_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkInertias_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkInertias::operator ()(iDynTree::LinkIndex const)\n"
    "    iDynTree::LinkInertias::operator ()(iDynTree::LinkIndex const) const\n");
  return 1;
}


int _wrap_delete_LinkInertias(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkInertias *arg1 = (iDynTree::LinkInertias *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_LinkInertias",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkInertias, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinkInertias" "', argument " "1"" of type '" "iDynTree::LinkInertias *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkInertias * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkArticulatedBodyInertias__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::LinkArticulatedBodyInertias *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkArticulatedBodyInertias",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinkArticulatedBodyInertias" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  result = (iDynTree::LinkArticulatedBodyInertias *)new iDynTree::LinkArticulatedBodyInertias(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkArticulatedBodyInertias__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::LinkArticulatedBodyInertias *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkArticulatedBodyInertias",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::LinkArticulatedBodyInertias *)new iDynTree::LinkArticulatedBodyInertias();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkArticulatedBodyInertias__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkArticulatedBodyInertias *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkArticulatedBodyInertias",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinkArticulatedBodyInertias" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinkArticulatedBodyInertias" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::LinkArticulatedBodyInertias *)new iDynTree::LinkArticulatedBodyInertias((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkArticulatedBodyInertias(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_LinkArticulatedBodyInertias__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LinkArticulatedBodyInertias__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LinkArticulatedBodyInertias__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_LinkArticulatedBodyInertias'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkArticulatedBodyInertias::LinkArticulatedBodyInertias(std::size_t)\n"
    "    iDynTree::LinkArticulatedBodyInertias::LinkArticulatedBodyInertias()\n"
    "    iDynTree::LinkArticulatedBodyInertias::LinkArticulatedBodyInertias(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkArticulatedBodyInertias_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkArticulatedBodyInertias *arg1 = (iDynTree::LinkArticulatedBodyInertias *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkArticulatedBodyInertias_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkArticulatedBodyInertias_resize" "', argument " "1"" of type '" "iDynTree::LinkArticulatedBodyInertias *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkArticulatedBodyInertias * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkArticulatedBodyInertias_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkArticulatedBodyInertias_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkArticulatedBodyInertias *arg1 = (iDynTree::LinkArticulatedBodyInertias *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkArticulatedBodyInertias_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkArticulatedBodyInertias_resize" "', argument " "1"" of type '" "iDynTree::LinkArticulatedBodyInertias *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkArticulatedBodyInertias * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkArticulatedBodyInertias_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkArticulatedBodyInertias_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkArticulatedBodyInertias_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LinkArticulatedBodyInertias_resize__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkArticulatedBodyInertias_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkArticulatedBodyInertias_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkArticulatedBodyInertias::resize(std::size_t)\n"
    "    iDynTree::LinkArticulatedBodyInertias::resize(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkArticulatedBodyInertias_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkArticulatedBodyInertias *arg1 = (iDynTree::LinkArticulatedBodyInertias *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("LinkArticulatedBodyInertias_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkArticulatedBodyInertias_isConsistent" "', argument " "1"" of type '" "iDynTree::LinkArticulatedBodyInertias const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkArticulatedBodyInertias * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkArticulatedBodyInertias_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkArticulatedBodyInertias_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::LinkArticulatedBodyInertias const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkArticulatedBodyInertias_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkArticulatedBodyInertias *arg1 = (iDynTree::LinkArticulatedBodyInertias *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::ArticulatedBodyInertia *result = 0 ;
  
  if (!SWIG_check_num_args("LinkArticulatedBodyInertias_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkArticulatedBodyInertias_paren" "', argument " "1"" of type '" "iDynTree::LinkArticulatedBodyInertias *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkArticulatedBodyInertias * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkArticulatedBodyInertias_paren" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::ArticulatedBodyInertia *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkArticulatedBodyInertias_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkArticulatedBodyInertias *arg1 = (iDynTree::LinkArticulatedBodyInertias *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::ArticulatedBodyInertia *result = 0 ;
  
  if (!SWIG_check_num_args("LinkArticulatedBodyInertias_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkArticulatedBodyInertias_paren" "', argument " "1"" of type '" "iDynTree::LinkArticulatedBodyInertias const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkArticulatedBodyInertias * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkArticulatedBodyInertias_paren" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::ArticulatedBodyInertia *) &((iDynTree::LinkArticulatedBodyInertias const *)arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ArticulatedBodyInertia, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkArticulatedBodyInertias_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkArticulatedBodyInertias_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkArticulatedBodyInertias_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkArticulatedBodyInertias_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkArticulatedBodyInertias::operator ()(iDynTree::LinkIndex const)\n"
    "    iDynTree::LinkArticulatedBodyInertias::operator ()(iDynTree::LinkIndex const) const\n");
  return 1;
}


int _wrap_delete_LinkArticulatedBodyInertias(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkArticulatedBodyInertias *arg1 = (iDynTree::LinkArticulatedBodyInertias *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_LinkArticulatedBodyInertias",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinkArticulatedBodyInertias" "', argument " "1"" of type '" "iDynTree::LinkArticulatedBodyInertias *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkArticulatedBodyInertias * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkVelArray__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::LinkVelArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkVelArray",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinkVelArray" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  result = (iDynTree::LinkVelArray *)new iDynTree::LinkVelArray(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkVelArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkVelArray__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::LinkVelArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkVelArray",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::LinkVelArray *)new iDynTree::LinkVelArray();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkVelArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkVelArray__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkVelArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkVelArray",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinkVelArray" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinkVelArray" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::LinkVelArray *)new iDynTree::LinkVelArray((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkVelArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkVelArray(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_LinkVelArray__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LinkVelArray__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LinkVelArray__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_LinkVelArray'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkVelArray::LinkVelArray(std::size_t)\n"
    "    iDynTree::LinkVelArray::LinkVelArray()\n"
    "    iDynTree::LinkVelArray::LinkVelArray(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkVelArray_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkVelArray *arg1 = (iDynTree::LinkVelArray *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkVelArray_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkVelArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkVelArray_resize" "', argument " "1"" of type '" "iDynTree::LinkVelArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkVelArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkVelArray_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkVelArray_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkVelArray *arg1 = (iDynTree::LinkVelArray *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkVelArray_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkVelArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkVelArray_resize" "', argument " "1"" of type '" "iDynTree::LinkVelArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkVelArray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkVelArray_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkVelArray_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkVelArray_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkVelArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LinkVelArray_resize__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkVelArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkVelArray_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkVelArray_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkVelArray::resize(std::size_t)\n"
    "    iDynTree::LinkVelArray::resize(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkVelArray_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkVelArray *arg1 = (iDynTree::LinkVelArray *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("LinkVelArray_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkVelArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkVelArray_isConsistent" "', argument " "1"" of type '" "iDynTree::LinkVelArray const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkVelArray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkVelArray_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkVelArray_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::LinkVelArray const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkVelArray_getNrOfLinks(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkVelArray *arg1 = (iDynTree::LinkVelArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("LinkVelArray_getNrOfLinks",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkVelArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkVelArray_getNrOfLinks" "', argument " "1"" of type '" "iDynTree::LinkVelArray const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkVelArray * >(argp1);
  result = ((iDynTree::LinkVelArray const *)arg1)->getNrOfLinks();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkVelArray_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkVelArray *arg1 = (iDynTree::LinkVelArray *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Twist *result = 0 ;
  
  if (!SWIG_check_num_args("LinkVelArray_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkVelArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkVelArray_paren" "', argument " "1"" of type '" "iDynTree::LinkVelArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkVelArray * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkVelArray_paren" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::Twist *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Twist, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkVelArray_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkVelArray *arg1 = (iDynTree::LinkVelArray *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Twist *result = 0 ;
  
  if (!SWIG_check_num_args("LinkVelArray_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkVelArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkVelArray_paren" "', argument " "1"" of type '" "iDynTree::LinkVelArray const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkVelArray * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkVelArray_paren" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::Twist *) &((iDynTree::LinkVelArray const *)arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Twist, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkVelArray_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkVelArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkVelArray_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkVelArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkVelArray_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkVelArray_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkVelArray::operator ()(iDynTree::LinkIndex const)\n"
    "    iDynTree::LinkVelArray::operator ()(iDynTree::LinkIndex const) const\n");
  return 1;
}


int _wrap_LinkVelArray_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkVelArray *arg1 = (iDynTree::LinkVelArray *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("LinkVelArray_toString",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkVelArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkVelArray_toString" "', argument " "1"" of type '" "iDynTree::LinkVelArray const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkVelArray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkVelArray_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkVelArray_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = ((iDynTree::LinkVelArray const *)arg1)->toString((iDynTree::Model const &)*arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_LinkVelArray(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkVelArray *arg1 = (iDynTree::LinkVelArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_LinkVelArray",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkVelArray, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinkVelArray" "', argument " "1"" of type '" "iDynTree::LinkVelArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkVelArray * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkAccArray__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::LinkAccArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkAccArray",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinkAccArray" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  result = (iDynTree::LinkAccArray *)new iDynTree::LinkAccArray(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkAccArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkAccArray__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::LinkAccArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkAccArray",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::LinkAccArray *)new iDynTree::LinkAccArray();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkAccArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkAccArray__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkAccArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkAccArray",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinkAccArray" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinkAccArray" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::LinkAccArray *)new iDynTree::LinkAccArray((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkAccArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkAccArray(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_LinkAccArray__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LinkAccArray__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LinkAccArray__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_LinkAccArray'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkAccArray::LinkAccArray(std::size_t)\n"
    "    iDynTree::LinkAccArray::LinkAccArray()\n"
    "    iDynTree::LinkAccArray::LinkAccArray(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkAccArray_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkAccArray *arg1 = (iDynTree::LinkAccArray *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkAccArray_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkAccArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkAccArray_resize" "', argument " "1"" of type '" "iDynTree::LinkAccArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkAccArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkAccArray_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkAccArray_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkAccArray *arg1 = (iDynTree::LinkAccArray *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkAccArray_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkAccArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkAccArray_resize" "', argument " "1"" of type '" "iDynTree::LinkAccArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkAccArray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkAccArray_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkAccArray_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkAccArray_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkAccArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LinkAccArray_resize__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkAccArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkAccArray_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkAccArray_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkAccArray::resize(std::size_t)\n"
    "    iDynTree::LinkAccArray::resize(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkAccArray_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkAccArray *arg1 = (iDynTree::LinkAccArray *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("LinkAccArray_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkAccArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkAccArray_isConsistent" "', argument " "1"" of type '" "iDynTree::LinkAccArray const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkAccArray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkAccArray_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkAccArray_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::LinkAccArray const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkAccArray_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkAccArray *arg1 = (iDynTree::LinkAccArray *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc *result = 0 ;
  
  if (!SWIG_check_num_args("LinkAccArray_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkAccArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkAccArray_paren" "', argument " "1"" of type '" "iDynTree::LinkAccArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkAccArray * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkAccArray_paren" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::SpatialAcc *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialAcc, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkAccArray_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkAccArray *arg1 = (iDynTree::LinkAccArray *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc *result = 0 ;
  
  if (!SWIG_check_num_args("LinkAccArray_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkAccArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkAccArray_paren" "', argument " "1"" of type '" "iDynTree::LinkAccArray const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkAccArray * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkAccArray_paren" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::SpatialAcc *) &((iDynTree::LinkAccArray const *)arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialAcc, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkAccArray_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkAccArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkAccArray_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkAccArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkAccArray_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkAccArray_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkAccArray::operator ()(iDynTree::LinkIndex const)\n"
    "    iDynTree::LinkAccArray::operator ()(iDynTree::LinkIndex const) const\n");
  return 1;
}


int _wrap_LinkAccArray_getNrOfLinks(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkAccArray *arg1 = (iDynTree::LinkAccArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("LinkAccArray_getNrOfLinks",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkAccArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkAccArray_getNrOfLinks" "', argument " "1"" of type '" "iDynTree::LinkAccArray const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkAccArray * >(argp1);
  result = ((iDynTree::LinkAccArray const *)arg1)->getNrOfLinks();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkAccArray_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkAccArray *arg1 = (iDynTree::LinkAccArray *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("LinkAccArray_toString",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkAccArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkAccArray_toString" "', argument " "1"" of type '" "iDynTree::LinkAccArray const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkAccArray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkAccArray_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkAccArray_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = ((iDynTree::LinkAccArray const *)arg1)->toString((iDynTree::Model const &)*arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_LinkAccArray(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkAccArray *arg1 = (iDynTree::LinkAccArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_LinkAccArray",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkAccArray, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinkAccArray" "', argument " "1"" of type '" "iDynTree::LinkAccArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkAccArray * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Link(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Link *result = 0 ;
  
  if (!SWIG_check_num_args("new_Link",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Link *)new iDynTree::Link();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Link, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Link_inertia__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Link *arg1 = (iDynTree::Link *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertia *result = 0 ;
  
  if (!SWIG_check_num_args("Link_inertia",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Link_inertia" "', argument " "1"" of type '" "iDynTree::Link *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Link * >(argp1);
  result = (iDynTree::SpatialInertia *) &(arg1)->inertia();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Link_inertia__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Link *arg1 = (iDynTree::Link *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertia *result = 0 ;
  
  if (!SWIG_check_num_args("Link_inertia",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Link_inertia" "', argument " "1"" of type '" "iDynTree::Link const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Link * >(argp1);
  result = (iDynTree::SpatialInertia *) &((iDynTree::Link const *)arg1)->inertia();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Link_inertia(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Link, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Link_inertia__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Link, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Link_inertia__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Link_inertia'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Link::inertia()\n"
    "    iDynTree::Link::inertia() const\n");
  return 1;
}


int _wrap_Link_setInertia(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Link *arg1 = (iDynTree::Link *) 0 ;
  iDynTree::SpatialInertia *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Link_setInertia",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Link_setInertia" "', argument " "1"" of type '" "iDynTree::Link *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Link * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialInertia,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Link_setInertia" "', argument " "2"" of type '" "iDynTree::SpatialInertia &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Link_setInertia" "', argument " "2"" of type '" "iDynTree::SpatialInertia &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialInertia * >(argp2);
  (arg1)->setInertia(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Link_getInertia(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Link *arg1 = (iDynTree::Link *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialInertia *result = 0 ;
  
  if (!SWIG_check_num_args("Link_getInertia",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Link_getInertia" "', argument " "1"" of type '" "iDynTree::Link const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Link * >(argp1);
  result = (iDynTree::SpatialInertia *) &((iDynTree::Link const *)arg1)->getInertia();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialInertia, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Link_setIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Link *arg1 = (iDynTree::Link *) 0 ;
  iDynTree::LinkIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Link_setIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Link_setIndex" "', argument " "1"" of type '" "iDynTree::Link *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Link * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__ptrdiff_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Link_setIndex" "', argument " "2"" of type '" "iDynTree::LinkIndex &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Link_setIndex" "', argument " "2"" of type '" "iDynTree::LinkIndex &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkIndex * >(argp2);
  (arg1)->setIndex(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Link_getIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Link *arg1 = (iDynTree::Link *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("Link_getIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Link_getIndex" "', argument " "1"" of type '" "iDynTree::Link const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Link * >(argp1);
  result = ((iDynTree::Link const *)arg1)->getIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Link(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Link *arg1 = (iDynTree::Link *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Link",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Link, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Link" "', argument " "1"" of type '" "iDynTree::Link *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Link * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_IJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_IJoint",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IJoint" "', argument " "1"" of type '" "iDynTree::IJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::IJoint *result = 0 ;
  
  if (!SWIG_check_num_args("IJoint_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_clone" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  result = (iDynTree::IJoint *)((iDynTree::IJoint const *)arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_getNrOfPosCoords(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("IJoint_getNrOfPosCoords",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_getNrOfPosCoords" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  result = (unsigned int)((iDynTree::IJoint const *)arg1)->getNrOfPosCoords();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_getNrOfDOFs(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("IJoint_getNrOfDOFs",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_getNrOfDOFs" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  result = (unsigned int)((iDynTree::IJoint const *)arg1)->getNrOfDOFs();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_setAttachedLinks(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IJoint_setAttachedLinks",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_setAttachedLinks" "', argument " "1"" of type '" "iDynTree::IJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IJoint_setAttachedLinks" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IJoint_setAttachedLinks" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  (arg1)->setAttachedLinks(arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_setRestTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IJoint_setRestTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_setRestTransform" "', argument " "1"" of type '" "iDynTree::IJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IJoint_setRestTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_setRestTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  (arg1)->setRestTransform((iDynTree::Transform const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_getFirstAttachedLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("IJoint_getFirstAttachedLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_getFirstAttachedLink" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  result = ((iDynTree::IJoint const *)arg1)->getFirstAttachedLink();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_getSecondAttachedLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("IJoint_getSecondAttachedLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_getSecondAttachedLink" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  result = ((iDynTree::IJoint const *)arg1)->getSecondAttachedLink();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_getRestTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("IJoint_getRestTransform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_getRestTransform" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IJoint_getRestTransform" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IJoint_getRestTransform" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  result = ((iDynTree::IJoint const *)arg1)->getRestTransform(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_getTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::LinkIndex arg3 ;
  iDynTree::LinkIndex arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  iDynTree::Transform *result = 0 ;
  
  if (!SWIG_check_num_args("IJoint_getTransform",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_getTransform" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IJoint_getTransform" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_getTransform" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IJoint_getTransform" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IJoint_getTransform" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  result = (iDynTree::Transform *) &((iDynTree::IJoint const *)arg1)->getTransform((iDynTree::VectorDynSize const &)*arg2,arg3,arg4);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_getTransformDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::LinkIndex arg3 ;
  iDynTree::LinkIndex arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  mxArray * _out;
  iDynTree::TransformDerivative result;
  
  if (!SWIG_check_num_args("IJoint_getTransformDerivative",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_getTransformDerivative" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IJoint_getTransformDerivative" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_getTransformDerivative" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IJoint_getTransformDerivative" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IJoint_getTransformDerivative" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IJoint_getTransformDerivative" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = ((iDynTree::IJoint const *)arg1)->getTransformDerivative((iDynTree::VectorDynSize const &)*arg2,arg3,arg4,arg5);
  _out = SWIG_NewPointerObj((new iDynTree::TransformDerivative(static_cast< const iDynTree::TransformDerivative& >(result))), SWIGTYPE_p_iDynTree__TransformDerivative, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_getMotionSubspaceVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  int arg2 ;
  iDynTree::LinkIndex arg3 ;
  iDynTree::LinkIndex arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("IJoint_getMotionSubspaceVector",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_getMotionSubspaceVector" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IJoint_getMotionSubspaceVector" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IJoint_getMotionSubspaceVector" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IJoint_getMotionSubspaceVector" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  result = ((iDynTree::IJoint const *)arg1)->getMotionSubspaceVector(arg2,arg3,arg4);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_computeChildPosVelAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  iDynTree::LinkPositions *arg5 = 0 ;
  iDynTree::LinkVelArray *arg6 = 0 ;
  iDynTree::LinkAccArray *arg7 = 0 ;
  iDynTree::LinkIndex arg8 ;
  iDynTree::LinkIndex arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  ptrdiff_t val8 ;
  int ecode8 = 0 ;
  ptrdiff_t val9 ;
  int ecode9 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IJoint_computeChildPosVelAcc",argc,9,9,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_computeChildPosVelAcc" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IJoint_computeChildPosVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildPosVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IJoint_computeChildPosVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildPosVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IJoint_computeChildPosVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildPosVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkPositions,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IJoint_computeChildPosVelAcc" "', argument " "5"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildPosVelAcc" "', argument " "5"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkPositions * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "IJoint_computeChildPosVelAcc" "', argument " "6"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildPosVelAcc" "', argument " "6"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkVelArray * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "IJoint_computeChildPosVelAcc" "', argument " "7"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildPosVelAcc" "', argument " "7"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::LinkAccArray * >(argp7);
  ecode8 = SWIG_AsVal_ptrdiff_t(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "IJoint_computeChildPosVelAcc" "', argument " "8"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg8 = static_cast< iDynTree::LinkIndex >(val8);
  ecode9 = SWIG_AsVal_ptrdiff_t(argv[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "IJoint_computeChildPosVelAcc" "', argument " "9"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg9 = static_cast< iDynTree::LinkIndex >(val9);
  ((iDynTree::IJoint const *)arg1)->computeChildPosVelAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::VectorDynSize const &)*arg4,*arg5,*arg6,*arg7,arg8,arg9);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_computeChildVelAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  iDynTree::LinkVelArray *arg5 = 0 ;
  iDynTree::LinkAccArray *arg6 = 0 ;
  iDynTree::LinkIndex arg7 ;
  iDynTree::LinkIndex arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  ptrdiff_t val7 ;
  int ecode7 = 0 ;
  ptrdiff_t val8 ;
  int ecode8 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IJoint_computeChildVelAcc",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_computeChildVelAcc" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IJoint_computeChildVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IJoint_computeChildVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IJoint_computeChildVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IJoint_computeChildVelAcc" "', argument " "5"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildVelAcc" "', argument " "5"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkVelArray * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "IJoint_computeChildVelAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildVelAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkAccArray * >(argp6);
  ecode7 = SWIG_AsVal_ptrdiff_t(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "IJoint_computeChildVelAcc" "', argument " "7"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg7 = static_cast< iDynTree::LinkIndex >(val7);
  ecode8 = SWIG_AsVal_ptrdiff_t(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "IJoint_computeChildVelAcc" "', argument " "8"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg8 = static_cast< iDynTree::LinkIndex >(val8);
  ((iDynTree::IJoint const *)arg1)->computeChildVelAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::VectorDynSize const &)*arg4,*arg5,*arg6,arg7,arg8);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_computeChildVel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::LinkIndex arg5 ;
  iDynTree::LinkIndex arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  ptrdiff_t val6 ;
  int ecode6 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IJoint_computeChildVel",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_computeChildVel" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IJoint_computeChildVel" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildVel" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IJoint_computeChildVel" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildVel" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IJoint_computeChildVel" "', argument " "4"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildVel" "', argument " "4"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IJoint_computeChildVel" "', argument " "5"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg5 = static_cast< iDynTree::LinkIndex >(val5);
  ecode6 = SWIG_AsVal_ptrdiff_t(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IJoint_computeChildVel" "', argument " "6"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg6 = static_cast< iDynTree::LinkIndex >(val6);
  ((iDynTree::IJoint const *)arg1)->computeChildVel((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,*arg4,arg5,arg6);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_computeChildAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::VectorDynSize *arg5 = 0 ;
  iDynTree::LinkAccArray *arg6 = 0 ;
  iDynTree::LinkIndex arg7 ;
  iDynTree::LinkIndex arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  ptrdiff_t val7 ;
  int ecode7 = 0 ;
  ptrdiff_t val8 ;
  int ecode8 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IJoint_computeChildAcc",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_computeChildAcc" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IJoint_computeChildAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IJoint_computeChildAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IJoint_computeChildAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IJoint_computeChildAcc" "', argument " "5"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildAcc" "', argument " "5"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::VectorDynSize * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "IJoint_computeChildAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkAccArray * >(argp6);
  ecode7 = SWIG_AsVal_ptrdiff_t(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "IJoint_computeChildAcc" "', argument " "7"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg7 = static_cast< iDynTree::LinkIndex >(val7);
  ecode8 = SWIG_AsVal_ptrdiff_t(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "IJoint_computeChildAcc" "', argument " "8"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg8 = static_cast< iDynTree::LinkIndex >(val8);
  ((iDynTree::IJoint const *)arg1)->computeChildAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::LinkVelArray const &)*arg4,(iDynTree::VectorDynSize const &)*arg5,*arg6,arg7,arg8);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_computeChildBiasAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::LinkAccArray *arg5 = 0 ;
  iDynTree::LinkIndex arg6 ;
  iDynTree::LinkIndex arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ptrdiff_t val6 ;
  int ecode6 = 0 ;
  ptrdiff_t val7 ;
  int ecode7 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IJoint_computeChildBiasAcc",argc,7,7,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_computeChildBiasAcc" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IJoint_computeChildBiasAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildBiasAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IJoint_computeChildBiasAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildBiasAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IJoint_computeChildBiasAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildBiasAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IJoint_computeChildBiasAcc" "', argument " "5"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeChildBiasAcc" "', argument " "5"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkAccArray * >(argp5);
  ecode6 = SWIG_AsVal_ptrdiff_t(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IJoint_computeChildBiasAcc" "', argument " "6"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg6 = static_cast< iDynTree::LinkIndex >(val6);
  ecode7 = SWIG_AsVal_ptrdiff_t(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "IJoint_computeChildBiasAcc" "', argument " "7"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg7 = static_cast< iDynTree::LinkIndex >(val7);
  ((iDynTree::IJoint const *)arg1)->computeChildBiasAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::LinkVelArray const &)*arg4,*arg5,arg6,arg7);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_computeJointTorque(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::Wrench *arg3 = 0 ;
  iDynTree::LinkIndex arg4 ;
  iDynTree::LinkIndex arg5 ;
  iDynTree::VectorDynSize *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IJoint_computeJointTorque",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_computeJointTorque" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IJoint_computeJointTorque" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeJointTorque" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IJoint_computeJointTorque" "', argument " "3"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeJointTorque" "', argument " "3"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Wrench * >(argp3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IJoint_computeJointTorque" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IJoint_computeJointTorque" "', argument " "5"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg5 = static_cast< iDynTree::LinkIndex >(val5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "IJoint_computeJointTorque" "', argument " "6"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_computeJointTorque" "', argument " "6"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::VectorDynSize * >(argp6);
  ((iDynTree::IJoint const *)arg1)->computeJointTorque((iDynTree::VectorDynSize const &)*arg2,(iDynTree::Wrench const &)*arg3,arg4,arg5,*arg6);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_setIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  iDynTree::JointIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IJoint_setIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_setIndex" "', argument " "1"" of type '" "iDynTree::IJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__ptrdiff_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IJoint_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointIndex * >(argp2);
  (arg1)->setIndex(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_getIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("IJoint_getIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_getIndex" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  result = ((iDynTree::IJoint const *)arg1)->getIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_setPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IJoint_setPosCoordsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_setPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::IJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IJoint_setPosCoordsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setPosCoordsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_getPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("IJoint_getPosCoordsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_getPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  result = ((iDynTree::IJoint const *)arg1)->getPosCoordsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_setDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IJoint_setDOFsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_setDOFsOffset" "', argument " "1"" of type '" "iDynTree::IJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IJoint_setDOFsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setDOFsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_getDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("IJoint_getDOFsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_getDOFsOffset" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  result = ((iDynTree::IJoint const *)arg1)->getDOFsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_hasPosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IJoint_hasPosLimits",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_hasPosLimits" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  result = (bool)((iDynTree::IJoint const *)arg1)->hasPosLimits();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_enablePosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IJoint_enablePosLimits",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_enablePosLimits" "', argument " "1"" of type '" "iDynTree::IJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IJoint_enablePosLimits" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->enablePosLimits(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_getPosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  size_t arg2 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IJoint_getPosLimits",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_getPosLimits" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IJoint_getPosLimits" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IJoint_getPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_getPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IJoint_getPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_getPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  result = (bool)((iDynTree::IJoint const *)arg1)->getPosLimits(arg2,*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_getMinPosLimit(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("IJoint_getMinPosLimit",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_getMinPosLimit" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IJoint_getMinPosLimit" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (double)((iDynTree::IJoint const *)arg1)->getMinPosLimit(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_getMaxPosLimit(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("IJoint_getMaxPosLimit",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_getMaxPosLimit" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IJoint_getMaxPosLimit" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (double)((iDynTree::IJoint const *)arg1)->getMaxPosLimit(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_setPosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  size_t arg2 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IJoint_setPosLimits",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_setPosLimits" "', argument " "1"" of type '" "iDynTree::IJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IJoint_setPosLimits" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IJoint_setPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_setPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IJoint_setPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJoint_setPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  result = (bool)(arg1)->setPosLimits(arg2,*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_isRevoluteJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IJoint_isRevoluteJoint",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_isRevoluteJoint" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  result = (bool)iDynTree_IJoint_isRevoluteJoint((iDynTree::IJoint const *)arg1);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_isFixedJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IJoint_isFixedJoint",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_isFixedJoint" "', argument " "1"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  result = (bool)iDynTree_IJoint_isFixedJoint((iDynTree::IJoint const *)arg1);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_asRevoluteJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::RevoluteJoint *result = 0 ;
  
  if (!SWIG_check_num_args("IJoint_asRevoluteJoint",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_asRevoluteJoint" "', argument " "1"" of type '" "iDynTree::IJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  result = (iDynTree::RevoluteJoint *)iDynTree_IJoint_asRevoluteJoint(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJoint_asFixedJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJoint *arg1 = (iDynTree::IJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::FixedJoint *result = 0 ;
  
  if (!SWIG_check_num_args("IJoint_asFixedJoint",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJoint_asFixedJoint" "', argument " "1"" of type '" "iDynTree::IJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJoint * >(argp1);
  result = (iDynTree::FixedJoint *)iDynTree_IJoint_asFixedJoint(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FixedJoint__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkIndex arg1 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::Transform *arg3 = 0 ;
  ptrdiff_t val1 ;
  int ecode1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::FixedJoint *result = 0 ;
  
  if (!SWIG_check_num_args("new_FixedJoint",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_ptrdiff_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FixedJoint" "', argument " "1"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg1 = static_cast< iDynTree::LinkIndex >(val1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FixedJoint" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FixedJoint" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedJoint" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (iDynTree::FixedJoint *)new iDynTree::FixedJoint(arg1,arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FixedJoint, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FixedJoint__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::FixedJoint *result = 0 ;
  
  if (!SWIG_check_num_args("new_FixedJoint",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedJoint" "', argument " "1"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedJoint" "', argument " "1"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  result = (iDynTree::FixedJoint *)new iDynTree::FixedJoint((iDynTree::Transform const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FixedJoint, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FixedJoint__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::FixedJoint *result = 0 ;
  
  if (!SWIG_check_num_args("new_FixedJoint",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__FixedJoint,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FixedJoint" "', argument " "1"" of type '" "iDynTree::FixedJoint const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FixedJoint" "', argument " "1"" of type '" "iDynTree::FixedJoint const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  result = (iDynTree::FixedJoint *)new iDynTree::FixedJoint((iDynTree::FixedJoint const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FixedJoint, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FixedJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FixedJoint__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FixedJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FixedJoint__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_ptrdiff_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_FixedJoint__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_FixedJoint'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FixedJoint::FixedJoint(iDynTree::LinkIndex const,iDynTree::LinkIndex const,iDynTree::Transform const &)\n"
    "    iDynTree::FixedJoint::FixedJoint(iDynTree::Transform const &)\n"
    "    iDynTree::FixedJoint::FixedJoint(iDynTree::FixedJoint const &)\n");
  return 1;
}


int _wrap_delete_FixedJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_FixedJoint",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FixedJoint" "', argument " "1"" of type '" "iDynTree::FixedJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::IJoint *result = 0 ;
  
  if (!SWIG_check_num_args("FixedJoint_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_clone" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  result = (iDynTree::IJoint *)((iDynTree::FixedJoint const *)arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_getNrOfPosCoords(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("FixedJoint_getNrOfPosCoords",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_getNrOfPosCoords" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  result = (unsigned int)((iDynTree::FixedJoint const *)arg1)->getNrOfPosCoords();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_getNrOfDOFs(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("FixedJoint_getNrOfDOFs",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_getNrOfDOFs" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  result = (unsigned int)((iDynTree::FixedJoint const *)arg1)->getNrOfDOFs();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_setAttachedLinks(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FixedJoint_setAttachedLinks",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_setAttachedLinks" "', argument " "1"" of type '" "iDynTree::FixedJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FixedJoint_setAttachedLinks" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FixedJoint_setAttachedLinks" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  (arg1)->setAttachedLinks(arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_setRestTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FixedJoint_setRestTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_setRestTransform" "', argument " "1"" of type '" "iDynTree::FixedJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedJoint_setRestTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_setRestTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  (arg1)->setRestTransform((iDynTree::Transform const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_getFirstAttachedLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("FixedJoint_getFirstAttachedLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_getFirstAttachedLink" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  result = ((iDynTree::FixedJoint const *)arg1)->getFirstAttachedLink();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_getSecondAttachedLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("FixedJoint_getSecondAttachedLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_getSecondAttachedLink" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  result = ((iDynTree::FixedJoint const *)arg1)->getSecondAttachedLink();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_getRestTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("FixedJoint_getRestTransform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_getRestTransform" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FixedJoint_getRestTransform" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FixedJoint_getRestTransform" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  result = ((iDynTree::FixedJoint const *)arg1)->getRestTransform(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_getTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::LinkIndex arg3 ;
  iDynTree::LinkIndex arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  iDynTree::Transform *result = 0 ;
  
  if (!SWIG_check_num_args("FixedJoint_getTransform",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_getTransform" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedJoint_getTransform" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_getTransform" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FixedJoint_getTransform" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FixedJoint_getTransform" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  result = (iDynTree::Transform *) &((iDynTree::FixedJoint const *)arg1)->getTransform((iDynTree::VectorDynSize const &)*arg2,arg3,arg4);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_getTransformDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::LinkIndex arg3 ;
  iDynTree::LinkIndex arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  mxArray * _out;
  iDynTree::TransformDerivative result;
  
  if (!SWIG_check_num_args("FixedJoint_getTransformDerivative",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_getTransformDerivative" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedJoint_getTransformDerivative" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_getTransformDerivative" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FixedJoint_getTransformDerivative" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FixedJoint_getTransformDerivative" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FixedJoint_getTransformDerivative" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = ((iDynTree::FixedJoint const *)arg1)->getTransformDerivative((iDynTree::VectorDynSize const &)*arg2,arg3,arg4,arg5);
  _out = SWIG_NewPointerObj((new iDynTree::TransformDerivative(static_cast< const iDynTree::TransformDerivative& >(result))), SWIGTYPE_p_iDynTree__TransformDerivative, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_getMotionSubspaceVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  int arg2 ;
  iDynTree::LinkIndex arg3 ;
  iDynTree::LinkIndex arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("FixedJoint_getMotionSubspaceVector",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_getMotionSubspaceVector" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FixedJoint_getMotionSubspaceVector" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FixedJoint_getMotionSubspaceVector" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FixedJoint_getMotionSubspaceVector" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  result = ((iDynTree::FixedJoint const *)arg1)->getMotionSubspaceVector(arg2,arg3,arg4);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_computeChildPosVelAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  iDynTree::LinkPositions *arg5 = 0 ;
  iDynTree::LinkVelArray *arg6 = 0 ;
  iDynTree::LinkAccArray *arg7 = 0 ;
  iDynTree::LinkIndex arg8 ;
  iDynTree::LinkIndex arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  ptrdiff_t val8 ;
  int ecode8 = 0 ;
  ptrdiff_t val9 ;
  int ecode9 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FixedJoint_computeChildPosVelAcc",argc,9,9,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkPositions,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "5"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "5"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkPositions * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "6"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "6"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkVelArray * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "7"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "7"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::LinkAccArray * >(argp7);
  ecode8 = SWIG_AsVal_ptrdiff_t(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "8"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg8 = static_cast< iDynTree::LinkIndex >(val8);
  ecode9 = SWIG_AsVal_ptrdiff_t(argv[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "FixedJoint_computeChildPosVelAcc" "', argument " "9"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg9 = static_cast< iDynTree::LinkIndex >(val9);
  ((iDynTree::FixedJoint const *)arg1)->computeChildPosVelAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::VectorDynSize const &)*arg4,*arg5,*arg6,*arg7,arg8,arg9);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_computeChildVelAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  iDynTree::LinkVelArray *arg5 = 0 ;
  iDynTree::LinkAccArray *arg6 = 0 ;
  iDynTree::LinkIndex arg7 ;
  iDynTree::LinkIndex arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  ptrdiff_t val7 ;
  int ecode7 = 0 ;
  ptrdiff_t val8 ;
  int ecode8 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FixedJoint_computeChildVelAcc",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_computeChildVelAcc" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedJoint_computeChildVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FixedJoint_computeChildVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FixedJoint_computeChildVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FixedJoint_computeChildVelAcc" "', argument " "5"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildVelAcc" "', argument " "5"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkVelArray * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "FixedJoint_computeChildVelAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildVelAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkAccArray * >(argp6);
  ecode7 = SWIG_AsVal_ptrdiff_t(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "FixedJoint_computeChildVelAcc" "', argument " "7"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg7 = static_cast< iDynTree::LinkIndex >(val7);
  ecode8 = SWIG_AsVal_ptrdiff_t(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FixedJoint_computeChildVelAcc" "', argument " "8"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg8 = static_cast< iDynTree::LinkIndex >(val8);
  ((iDynTree::FixedJoint const *)arg1)->computeChildVelAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::VectorDynSize const &)*arg4,*arg5,*arg6,arg7,arg8);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_computeChildVel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::LinkIndex arg5 ;
  iDynTree::LinkIndex arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  ptrdiff_t val6 ;
  int ecode6 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FixedJoint_computeChildVel",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_computeChildVel" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedJoint_computeChildVel" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildVel" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FixedJoint_computeChildVel" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildVel" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FixedJoint_computeChildVel" "', argument " "4"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildVel" "', argument " "4"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FixedJoint_computeChildVel" "', argument " "5"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg5 = static_cast< iDynTree::LinkIndex >(val5);
  ecode6 = SWIG_AsVal_ptrdiff_t(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FixedJoint_computeChildVel" "', argument " "6"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg6 = static_cast< iDynTree::LinkIndex >(val6);
  ((iDynTree::FixedJoint const *)arg1)->computeChildVel((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,*arg4,arg5,arg6);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_computeChildAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::VectorDynSize *arg5 = 0 ;
  iDynTree::LinkAccArray *arg6 = 0 ;
  iDynTree::LinkIndex arg7 ;
  iDynTree::LinkIndex arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  ptrdiff_t val7 ;
  int ecode7 = 0 ;
  ptrdiff_t val8 ;
  int ecode8 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FixedJoint_computeChildAcc",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_computeChildAcc" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedJoint_computeChildAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FixedJoint_computeChildAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FixedJoint_computeChildAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FixedJoint_computeChildAcc" "', argument " "5"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildAcc" "', argument " "5"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::VectorDynSize * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "FixedJoint_computeChildAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkAccArray * >(argp6);
  ecode7 = SWIG_AsVal_ptrdiff_t(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "FixedJoint_computeChildAcc" "', argument " "7"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg7 = static_cast< iDynTree::LinkIndex >(val7);
  ecode8 = SWIG_AsVal_ptrdiff_t(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "FixedJoint_computeChildAcc" "', argument " "8"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg8 = static_cast< iDynTree::LinkIndex >(val8);
  ((iDynTree::FixedJoint const *)arg1)->computeChildAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::LinkVelArray const &)*arg4,(iDynTree::VectorDynSize const &)*arg5,*arg6,arg7,arg8);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_computeChildBiasAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::LinkAccArray *arg5 = 0 ;
  iDynTree::LinkIndex arg6 ;
  iDynTree::LinkIndex arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ptrdiff_t val6 ;
  int ecode6 = 0 ;
  ptrdiff_t val7 ;
  int ecode7 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FixedJoint_computeChildBiasAcc",argc,7,7,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_computeChildBiasAcc" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedJoint_computeChildBiasAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildBiasAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FixedJoint_computeChildBiasAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildBiasAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FixedJoint_computeChildBiasAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildBiasAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FixedJoint_computeChildBiasAcc" "', argument " "5"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeChildBiasAcc" "', argument " "5"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkAccArray * >(argp5);
  ecode6 = SWIG_AsVal_ptrdiff_t(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "FixedJoint_computeChildBiasAcc" "', argument " "6"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg6 = static_cast< iDynTree::LinkIndex >(val6);
  ecode7 = SWIG_AsVal_ptrdiff_t(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "FixedJoint_computeChildBiasAcc" "', argument " "7"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg7 = static_cast< iDynTree::LinkIndex >(val7);
  ((iDynTree::FixedJoint const *)arg1)->computeChildBiasAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::LinkVelArray const &)*arg4,*arg5,arg6,arg7);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_computeJointTorque(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::Wrench *arg3 = 0 ;
  iDynTree::LinkIndex arg4 ;
  iDynTree::LinkIndex arg5 ;
  iDynTree::VectorDynSize *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FixedJoint_computeJointTorque",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_computeJointTorque" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedJoint_computeJointTorque" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeJointTorque" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FixedJoint_computeJointTorque" "', argument " "3"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeJointTorque" "', argument " "3"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Wrench * >(argp3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FixedJoint_computeJointTorque" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "FixedJoint_computeJointTorque" "', argument " "5"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg5 = static_cast< iDynTree::LinkIndex >(val5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "FixedJoint_computeJointTorque" "', argument " "6"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_computeJointTorque" "', argument " "6"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::VectorDynSize * >(argp6);
  ((iDynTree::FixedJoint const *)arg1)->computeJointTorque((iDynTree::VectorDynSize const &)*arg2,(iDynTree::Wrench const &)*arg3,arg4,arg5,*arg6);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_setIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  iDynTree::JointIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FixedJoint_setIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_setIndex" "', argument " "1"" of type '" "iDynTree::FixedJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__ptrdiff_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FixedJoint_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointIndex * >(argp2);
  (arg1)->setIndex(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_getIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("FixedJoint_getIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_getIndex" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  result = ((iDynTree::FixedJoint const *)arg1)->getIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_setPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FixedJoint_setPosCoordsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_setPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::FixedJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FixedJoint_setPosCoordsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setPosCoordsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_getPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("FixedJoint_getPosCoordsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_getPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  result = ((iDynTree::FixedJoint const *)arg1)->getPosCoordsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_setDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FixedJoint_setDOFsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_setDOFsOffset" "', argument " "1"" of type '" "iDynTree::FixedJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FixedJoint_setDOFsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setDOFsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_getDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("FixedJoint_getDOFsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_getDOFsOffset" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  result = ((iDynTree::FixedJoint const *)arg1)->getDOFsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_hasPosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("FixedJoint_hasPosLimits",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_hasPosLimits" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  result = (bool)((iDynTree::FixedJoint const *)arg1)->hasPosLimits();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_enablePosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("FixedJoint_enablePosLimits",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_enablePosLimits" "', argument " "1"" of type '" "iDynTree::FixedJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FixedJoint_enablePosLimits" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->enablePosLimits(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_getPosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  size_t arg2 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("FixedJoint_getPosLimits",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_getPosLimits" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FixedJoint_getPosLimits" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FixedJoint_getPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_getPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FixedJoint_getPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_getPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  result = (bool)((iDynTree::FixedJoint const *)arg1)->getPosLimits(arg2,*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_getMinPosLimit(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("FixedJoint_getMinPosLimit",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_getMinPosLimit" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FixedJoint_getMinPosLimit" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (double)((iDynTree::FixedJoint const *)arg1)->getMinPosLimit(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_getMaxPosLimit(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("FixedJoint_getMaxPosLimit",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_getMaxPosLimit" "', argument " "1"" of type '" "iDynTree::FixedJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FixedJoint_getMaxPosLimit" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (double)((iDynTree::FixedJoint const *)arg1)->getMaxPosLimit(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FixedJoint_setPosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FixedJoint *arg1 = (iDynTree::FixedJoint *) 0 ;
  size_t arg2 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("FixedJoint_setPosLimits",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FixedJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedJoint_setPosLimits" "', argument " "1"" of type '" "iDynTree::FixedJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FixedJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FixedJoint_setPosLimits" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FixedJoint_setPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_setPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FixedJoint_setPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedJoint_setPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  result = (bool)(arg1)->setPosLimits(arg2,*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_MovableJointImpl1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 1,1 > *arg1 = (iDynTree::MovableJointImpl< 1,1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_MovableJointImpl1",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_1_1_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MovableJointImpl1" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 1,1 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 1,1 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl1_getNrOfPosCoords(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 1,1 > *arg1 = (iDynTree::MovableJointImpl< 1,1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("MovableJointImpl1_getNrOfPosCoords",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_1_1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl1_getNrOfPosCoords" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 1,1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 1,1 > * >(argp1);
  result = (unsigned int)((iDynTree::MovableJointImpl< 1,1 > const *)arg1)->getNrOfPosCoords();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl1_getNrOfDOFs(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 1,1 > *arg1 = (iDynTree::MovableJointImpl< 1,1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("MovableJointImpl1_getNrOfDOFs",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_1_1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl1_getNrOfDOFs" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 1,1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 1,1 > * >(argp1);
  result = (unsigned int)((iDynTree::MovableJointImpl< 1,1 > const *)arg1)->getNrOfDOFs();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl1_setIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 1,1 > *arg1 = (iDynTree::MovableJointImpl< 1,1 > *) 0 ;
  iDynTree::JointIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl1_setIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_1_1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl1_setIndex" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 1,1 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 1,1 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__ptrdiff_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MovableJointImpl1_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MovableJointImpl1_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointIndex * >(argp2);
  (arg1)->setIndex(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl1_getIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 1,1 > *arg1 = (iDynTree::MovableJointImpl< 1,1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("MovableJointImpl1_getIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_1_1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl1_getIndex" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 1,1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 1,1 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 1,1 > const *)arg1)->getIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl1_setPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 1,1 > *arg1 = (iDynTree::MovableJointImpl< 1,1 > *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl1_setPosCoordsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_1_1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl1_setPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 1,1 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 1,1 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MovableJointImpl1_setPosCoordsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setPosCoordsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl1_getPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 1,1 > *arg1 = (iDynTree::MovableJointImpl< 1,1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("MovableJointImpl1_getPosCoordsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_1_1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl1_getPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 1,1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 1,1 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 1,1 > const *)arg1)->getPosCoordsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl1_setDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 1,1 > *arg1 = (iDynTree::MovableJointImpl< 1,1 > *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl1_setDOFsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_1_1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl1_setDOFsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 1,1 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 1,1 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MovableJointImpl1_setDOFsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setDOFsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl1_getDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 1,1 > *arg1 = (iDynTree::MovableJointImpl< 1,1 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("MovableJointImpl1_getDOFsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_1_1_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl1_getDOFsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 1,1 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 1,1 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 1,1 > const *)arg1)->getDOFsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_MovableJointImpl2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 2,2 > *arg1 = (iDynTree::MovableJointImpl< 2,2 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_MovableJointImpl2",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_2_2_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MovableJointImpl2" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 2,2 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 2,2 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl2_getNrOfPosCoords(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 2,2 > *arg1 = (iDynTree::MovableJointImpl< 2,2 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("MovableJointImpl2_getNrOfPosCoords",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_2_2_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl2_getNrOfPosCoords" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 2,2 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 2,2 > * >(argp1);
  result = (unsigned int)((iDynTree::MovableJointImpl< 2,2 > const *)arg1)->getNrOfPosCoords();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl2_getNrOfDOFs(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 2,2 > *arg1 = (iDynTree::MovableJointImpl< 2,2 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("MovableJointImpl2_getNrOfDOFs",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_2_2_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl2_getNrOfDOFs" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 2,2 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 2,2 > * >(argp1);
  result = (unsigned int)((iDynTree::MovableJointImpl< 2,2 > const *)arg1)->getNrOfDOFs();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl2_setIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 2,2 > *arg1 = (iDynTree::MovableJointImpl< 2,2 > *) 0 ;
  iDynTree::JointIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl2_setIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_2_2_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl2_setIndex" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 2,2 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 2,2 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__ptrdiff_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MovableJointImpl2_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MovableJointImpl2_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointIndex * >(argp2);
  (arg1)->setIndex(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl2_getIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 2,2 > *arg1 = (iDynTree::MovableJointImpl< 2,2 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("MovableJointImpl2_getIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_2_2_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl2_getIndex" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 2,2 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 2,2 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 2,2 > const *)arg1)->getIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl2_setPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 2,2 > *arg1 = (iDynTree::MovableJointImpl< 2,2 > *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl2_setPosCoordsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_2_2_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl2_setPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 2,2 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 2,2 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MovableJointImpl2_setPosCoordsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setPosCoordsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl2_getPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 2,2 > *arg1 = (iDynTree::MovableJointImpl< 2,2 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("MovableJointImpl2_getPosCoordsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_2_2_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl2_getPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 2,2 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 2,2 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 2,2 > const *)arg1)->getPosCoordsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl2_setDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 2,2 > *arg1 = (iDynTree::MovableJointImpl< 2,2 > *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl2_setDOFsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_2_2_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl2_setDOFsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 2,2 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 2,2 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MovableJointImpl2_setDOFsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setDOFsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl2_getDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 2,2 > *arg1 = (iDynTree::MovableJointImpl< 2,2 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("MovableJointImpl2_getDOFsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_2_2_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl2_getDOFsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 2,2 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 2,2 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 2,2 > const *)arg1)->getDOFsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_MovableJointImpl3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 3,3 > *arg1 = (iDynTree::MovableJointImpl< 3,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_MovableJointImpl3",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_3_3_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MovableJointImpl3" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 3,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 3,3 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl3_getNrOfPosCoords(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 3,3 > *arg1 = (iDynTree::MovableJointImpl< 3,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("MovableJointImpl3_getNrOfPosCoords",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl3_getNrOfPosCoords" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 3,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 3,3 > * >(argp1);
  result = (unsigned int)((iDynTree::MovableJointImpl< 3,3 > const *)arg1)->getNrOfPosCoords();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl3_getNrOfDOFs(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 3,3 > *arg1 = (iDynTree::MovableJointImpl< 3,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("MovableJointImpl3_getNrOfDOFs",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl3_getNrOfDOFs" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 3,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 3,3 > * >(argp1);
  result = (unsigned int)((iDynTree::MovableJointImpl< 3,3 > const *)arg1)->getNrOfDOFs();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl3_setIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 3,3 > *arg1 = (iDynTree::MovableJointImpl< 3,3 > *) 0 ;
  iDynTree::JointIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl3_setIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl3_setIndex" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 3,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 3,3 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__ptrdiff_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MovableJointImpl3_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MovableJointImpl3_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointIndex * >(argp2);
  (arg1)->setIndex(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl3_getIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 3,3 > *arg1 = (iDynTree::MovableJointImpl< 3,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("MovableJointImpl3_getIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl3_getIndex" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 3,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 3,3 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 3,3 > const *)arg1)->getIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl3_setPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 3,3 > *arg1 = (iDynTree::MovableJointImpl< 3,3 > *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl3_setPosCoordsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl3_setPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 3,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 3,3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MovableJointImpl3_setPosCoordsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setPosCoordsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl3_getPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 3,3 > *arg1 = (iDynTree::MovableJointImpl< 3,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("MovableJointImpl3_getPosCoordsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl3_getPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 3,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 3,3 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 3,3 > const *)arg1)->getPosCoordsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl3_setDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 3,3 > *arg1 = (iDynTree::MovableJointImpl< 3,3 > *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl3_setDOFsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl3_setDOFsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 3,3 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 3,3 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MovableJointImpl3_setDOFsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setDOFsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl3_getDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 3,3 > *arg1 = (iDynTree::MovableJointImpl< 3,3 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("MovableJointImpl3_getDOFsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_3_3_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl3_getDOFsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 3,3 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 3,3 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 3,3 > const *)arg1)->getDOFsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_MovableJointImpl4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 4,4 > *arg1 = (iDynTree::MovableJointImpl< 4,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_MovableJointImpl4",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_4_4_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MovableJointImpl4" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 4,4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 4,4 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl4_getNrOfPosCoords(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 4,4 > *arg1 = (iDynTree::MovableJointImpl< 4,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("MovableJointImpl4_getNrOfPosCoords",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl4_getNrOfPosCoords" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 4,4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 4,4 > * >(argp1);
  result = (unsigned int)((iDynTree::MovableJointImpl< 4,4 > const *)arg1)->getNrOfPosCoords();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl4_getNrOfDOFs(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 4,4 > *arg1 = (iDynTree::MovableJointImpl< 4,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("MovableJointImpl4_getNrOfDOFs",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl4_getNrOfDOFs" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 4,4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 4,4 > * >(argp1);
  result = (unsigned int)((iDynTree::MovableJointImpl< 4,4 > const *)arg1)->getNrOfDOFs();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl4_setIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 4,4 > *arg1 = (iDynTree::MovableJointImpl< 4,4 > *) 0 ;
  iDynTree::JointIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl4_setIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl4_setIndex" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 4,4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 4,4 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__ptrdiff_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MovableJointImpl4_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MovableJointImpl4_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointIndex * >(argp2);
  (arg1)->setIndex(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl4_getIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 4,4 > *arg1 = (iDynTree::MovableJointImpl< 4,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("MovableJointImpl4_getIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl4_getIndex" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 4,4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 4,4 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 4,4 > const *)arg1)->getIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl4_setPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 4,4 > *arg1 = (iDynTree::MovableJointImpl< 4,4 > *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl4_setPosCoordsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl4_setPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 4,4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 4,4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MovableJointImpl4_setPosCoordsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setPosCoordsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl4_getPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 4,4 > *arg1 = (iDynTree::MovableJointImpl< 4,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("MovableJointImpl4_getPosCoordsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl4_getPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 4,4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 4,4 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 4,4 > const *)arg1)->getPosCoordsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl4_setDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 4,4 > *arg1 = (iDynTree::MovableJointImpl< 4,4 > *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl4_setDOFsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl4_setDOFsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 4,4 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 4,4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MovableJointImpl4_setDOFsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setDOFsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl4_getDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 4,4 > *arg1 = (iDynTree::MovableJointImpl< 4,4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("MovableJointImpl4_getDOFsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_4_4_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl4_getDOFsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 4,4 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 4,4 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 4,4 > const *)arg1)->getDOFsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_MovableJointImpl5(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 5,5 > *arg1 = (iDynTree::MovableJointImpl< 5,5 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_MovableJointImpl5",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_5_5_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MovableJointImpl5" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 5,5 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 5,5 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl5_getNrOfPosCoords(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 5,5 > *arg1 = (iDynTree::MovableJointImpl< 5,5 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("MovableJointImpl5_getNrOfPosCoords",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_5_5_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl5_getNrOfPosCoords" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 5,5 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 5,5 > * >(argp1);
  result = (unsigned int)((iDynTree::MovableJointImpl< 5,5 > const *)arg1)->getNrOfPosCoords();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl5_getNrOfDOFs(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 5,5 > *arg1 = (iDynTree::MovableJointImpl< 5,5 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("MovableJointImpl5_getNrOfDOFs",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_5_5_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl5_getNrOfDOFs" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 5,5 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 5,5 > * >(argp1);
  result = (unsigned int)((iDynTree::MovableJointImpl< 5,5 > const *)arg1)->getNrOfDOFs();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl5_setIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 5,5 > *arg1 = (iDynTree::MovableJointImpl< 5,5 > *) 0 ;
  iDynTree::JointIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl5_setIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_5_5_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl5_setIndex" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 5,5 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 5,5 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__ptrdiff_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MovableJointImpl5_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MovableJointImpl5_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointIndex * >(argp2);
  (arg1)->setIndex(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl5_getIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 5,5 > *arg1 = (iDynTree::MovableJointImpl< 5,5 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("MovableJointImpl5_getIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_5_5_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl5_getIndex" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 5,5 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 5,5 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 5,5 > const *)arg1)->getIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl5_setPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 5,5 > *arg1 = (iDynTree::MovableJointImpl< 5,5 > *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl5_setPosCoordsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_5_5_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl5_setPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 5,5 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 5,5 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MovableJointImpl5_setPosCoordsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setPosCoordsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl5_getPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 5,5 > *arg1 = (iDynTree::MovableJointImpl< 5,5 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("MovableJointImpl5_getPosCoordsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_5_5_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl5_getPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 5,5 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 5,5 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 5,5 > const *)arg1)->getPosCoordsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl5_setDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 5,5 > *arg1 = (iDynTree::MovableJointImpl< 5,5 > *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl5_setDOFsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_5_5_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl5_setDOFsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 5,5 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 5,5 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MovableJointImpl5_setDOFsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setDOFsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl5_getDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 5,5 > *arg1 = (iDynTree::MovableJointImpl< 5,5 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("MovableJointImpl5_getDOFsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_5_5_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl5_getDOFsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 5,5 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 5,5 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 5,5 > const *)arg1)->getDOFsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_MovableJointImpl6(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 6,6 > *arg1 = (iDynTree::MovableJointImpl< 6,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_MovableJointImpl6",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_6_6_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MovableJointImpl6" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 6,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 6,6 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl6_getNrOfPosCoords(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 6,6 > *arg1 = (iDynTree::MovableJointImpl< 6,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("MovableJointImpl6_getNrOfPosCoords",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl6_getNrOfPosCoords" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 6,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 6,6 > * >(argp1);
  result = (unsigned int)((iDynTree::MovableJointImpl< 6,6 > const *)arg1)->getNrOfPosCoords();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl6_getNrOfDOFs(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 6,6 > *arg1 = (iDynTree::MovableJointImpl< 6,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("MovableJointImpl6_getNrOfDOFs",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl6_getNrOfDOFs" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 6,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 6,6 > * >(argp1);
  result = (unsigned int)((iDynTree::MovableJointImpl< 6,6 > const *)arg1)->getNrOfDOFs();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl6_setIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 6,6 > *arg1 = (iDynTree::MovableJointImpl< 6,6 > *) 0 ;
  iDynTree::JointIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl6_setIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl6_setIndex" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 6,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 6,6 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__ptrdiff_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MovableJointImpl6_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MovableJointImpl6_setIndex" "', argument " "2"" of type '" "iDynTree::JointIndex &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointIndex * >(argp2);
  (arg1)->setIndex(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl6_getIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 6,6 > *arg1 = (iDynTree::MovableJointImpl< 6,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("MovableJointImpl6_getIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl6_getIndex" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 6,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 6,6 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 6,6 > const *)arg1)->getIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl6_setPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 6,6 > *arg1 = (iDynTree::MovableJointImpl< 6,6 > *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl6_setPosCoordsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl6_setPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 6,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 6,6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MovableJointImpl6_setPosCoordsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setPosCoordsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl6_getPosCoordsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 6,6 > *arg1 = (iDynTree::MovableJointImpl< 6,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("MovableJointImpl6_getPosCoordsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl6_getPosCoordsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 6,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 6,6 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 6,6 > const *)arg1)->getPosCoordsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl6_setDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 6,6 > *arg1 = (iDynTree::MovableJointImpl< 6,6 > *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MovableJointImpl6_setDOFsOffset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl6_setDOFsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 6,6 > *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 6,6 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MovableJointImpl6_setDOFsOffset" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setDOFsOffset(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MovableJointImpl6_getDOFsOffset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MovableJointImpl< 6,6 > *arg1 = (iDynTree::MovableJointImpl< 6,6 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("MovableJointImpl6_getDOFsOffset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MovableJointImplT_6_6_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MovableJointImpl6_getDOFsOffset" "', argument " "1"" of type '" "iDynTree::MovableJointImpl< 6,6 > const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MovableJointImpl< 6,6 > * >(argp1);
  result = ((iDynTree::MovableJointImpl< 6,6 > const *)arg1)->getDOFsOffset();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RevoluteJoint__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::RevoluteJoint *result = 0 ;
  
  if (!SWIG_check_num_args("new_RevoluteJoint",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::RevoluteJoint *)new iDynTree::RevoluteJoint();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RevoluteJoint, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RevoluteJoint__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkIndex arg1 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::Transform *arg3 = 0 ;
  iDynTree::Axis *arg4 = 0 ;
  ptrdiff_t val1 ;
  int ecode1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  iDynTree::RevoluteJoint *result = 0 ;
  
  if (!SWIG_check_num_args("new_RevoluteJoint",argc,4,4,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_ptrdiff_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RevoluteJoint" "', argument " "1"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg1 = static_cast< iDynTree::LinkIndex >(val1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RevoluteJoint" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RevoluteJoint" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RevoluteJoint" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Axis,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_RevoluteJoint" "', argument " "4"" of type '" "iDynTree::Axis const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RevoluteJoint" "', argument " "4"" of type '" "iDynTree::Axis const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Axis * >(argp4);
  result = (iDynTree::RevoluteJoint *)new iDynTree::RevoluteJoint(arg1,arg2,(iDynTree::Transform const &)*arg3,(iDynTree::Axis const &)*arg4);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RevoluteJoint, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RevoluteJoint__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Transform *arg1 = 0 ;
  iDynTree::Axis *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::RevoluteJoint *result = 0 ;
  
  if (!SWIG_check_num_args("new_RevoluteJoint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RevoluteJoint" "', argument " "1"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RevoluteJoint" "', argument " "1"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Transform * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Axis,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RevoluteJoint" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RevoluteJoint" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Axis * >(argp2);
  result = (iDynTree::RevoluteJoint *)new iDynTree::RevoluteJoint((iDynTree::Transform const &)*arg1,(iDynTree::Axis const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RevoluteJoint, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RevoluteJoint__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::RevoluteJoint *result = 0 ;
  
  if (!SWIG_check_num_args("new_RevoluteJoint",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__RevoluteJoint,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RevoluteJoint" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RevoluteJoint" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  result = (iDynTree::RevoluteJoint *)new iDynTree::RevoluteJoint((iDynTree::RevoluteJoint const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__RevoluteJoint, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_RevoluteJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_RevoluteJoint__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__RevoluteJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RevoluteJoint__SWIG_3(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_RevoluteJoint__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_ptrdiff_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Axis, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_RevoluteJoint__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_RevoluteJoint'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::RevoluteJoint::RevoluteJoint()\n"
    "    iDynTree::RevoluteJoint::RevoluteJoint(iDynTree::LinkIndex const,iDynTree::LinkIndex const,iDynTree::Transform const &,iDynTree::Axis const &)\n"
    "    iDynTree::RevoluteJoint::RevoluteJoint(iDynTree::Transform const &,iDynTree::Axis const &)\n"
    "    iDynTree::RevoluteJoint::RevoluteJoint(iDynTree::RevoluteJoint const &)\n");
  return 1;
}


int _wrap_delete_RevoluteJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_RevoluteJoint",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RevoluteJoint" "', argument " "1"" of type '" "iDynTree::RevoluteJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::IJoint *result = 0 ;
  
  if (!SWIG_check_num_args("RevoluteJoint_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_clone" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  result = (iDynTree::IJoint *)((iDynTree::RevoluteJoint const *)arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_setAttachedLinks(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RevoluteJoint_setAttachedLinks",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_setAttachedLinks" "', argument " "1"" of type '" "iDynTree::RevoluteJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RevoluteJoint_setAttachedLinks" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RevoluteJoint_setAttachedLinks" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  (arg1)->setAttachedLinks(arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_setRestTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RevoluteJoint_setRestTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_setRestTransform" "', argument " "1"" of type '" "iDynTree::RevoluteJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RevoluteJoint_setRestTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_setRestTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  (arg1)->setRestTransform((iDynTree::Transform const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_setAxis__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::Axis *arg2 = 0 ;
  iDynTree::LinkIndex arg3 ;
  iDynTree::LinkIndex arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RevoluteJoint_setAxis",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_setAxis" "', argument " "1"" of type '" "iDynTree::RevoluteJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Axis,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RevoluteJoint_setAxis" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_setAxis" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Axis * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RevoluteJoint_setAxis" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RevoluteJoint_setAxis" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  (arg1)->setAxis((iDynTree::Axis const &)*arg2,arg3,arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_setAxis__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::Axis *arg2 = 0 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RevoluteJoint_setAxis",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_setAxis" "', argument " "1"" of type '" "iDynTree::RevoluteJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Axis,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RevoluteJoint_setAxis" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_setAxis" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Axis * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RevoluteJoint_setAxis" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  (arg1)->setAxis((iDynTree::Axis const &)*arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_setAxis__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::Axis *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RevoluteJoint_setAxis",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_setAxis" "', argument " "1"" of type '" "iDynTree::RevoluteJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Axis,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RevoluteJoint_setAxis" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_setAxis" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Axis * >(argp2);
  (arg1)->setAxis((iDynTree::Axis const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_setAxis(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__RevoluteJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RevoluteJoint_setAxis__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__RevoluteJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RevoluteJoint_setAxis__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__RevoluteJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_ptrdiff_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_RevoluteJoint_setAxis__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'RevoluteJoint_setAxis'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::RevoluteJoint::setAxis(iDynTree::Axis const &,iDynTree::LinkIndex const,iDynTree::LinkIndex const)\n"
    "    iDynTree::RevoluteJoint::setAxis(iDynTree::Axis const &,iDynTree::LinkIndex const)\n"
    "    iDynTree::RevoluteJoint::setAxis(iDynTree::Axis const &)\n");
  return 1;
}


int _wrap_RevoluteJoint_getFirstAttachedLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("RevoluteJoint_getFirstAttachedLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_getFirstAttachedLink" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  result = ((iDynTree::RevoluteJoint const *)arg1)->getFirstAttachedLink();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_getSecondAttachedLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("RevoluteJoint_getSecondAttachedLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_getSecondAttachedLink" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  result = ((iDynTree::RevoluteJoint const *)arg1)->getSecondAttachedLink();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_getAxis__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::Axis result;
  
  if (!SWIG_check_num_args("RevoluteJoint_getAxis",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_getAxis" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RevoluteJoint_getAxis" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RevoluteJoint_getAxis" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  result = ((iDynTree::RevoluteJoint const *)arg1)->getAxis(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Axis(static_cast< const iDynTree::Axis& >(result))), SWIGTYPE_p_iDynTree__Axis, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_getAxis__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Axis result;
  
  if (!SWIG_check_num_args("RevoluteJoint_getAxis",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_getAxis" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RevoluteJoint_getAxis" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = ((iDynTree::RevoluteJoint const *)arg1)->getAxis(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Axis(static_cast< const iDynTree::Axis& >(result))), SWIGTYPE_p_iDynTree__Axis, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_getAxis(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__RevoluteJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RevoluteJoint_getAxis__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__RevoluteJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RevoluteJoint_getAxis__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'RevoluteJoint_getAxis'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::RevoluteJoint::getAxis(iDynTree::LinkIndex const,iDynTree::LinkIndex const) const\n"
    "    iDynTree::RevoluteJoint::getAxis(iDynTree::LinkIndex const) const\n");
  return 1;
}


int _wrap_RevoluteJoint_getRestTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("RevoluteJoint_getRestTransform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_getRestTransform" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RevoluteJoint_getRestTransform" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RevoluteJoint_getRestTransform" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  result = ((iDynTree::RevoluteJoint const *)arg1)->getRestTransform(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_getTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::LinkIndex arg3 ;
  iDynTree::LinkIndex arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  iDynTree::Transform *result = 0 ;
  
  if (!SWIG_check_num_args("RevoluteJoint_getTransform",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_getTransform" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RevoluteJoint_getTransform" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_getTransform" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RevoluteJoint_getTransform" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RevoluteJoint_getTransform" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  result = (iDynTree::Transform *) &((iDynTree::RevoluteJoint const *)arg1)->getTransform((iDynTree::VectorDynSize const &)*arg2,arg3,arg4);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_getTransformDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::LinkIndex arg3 ;
  iDynTree::LinkIndex arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  mxArray * _out;
  iDynTree::TransformDerivative result;
  
  if (!SWIG_check_num_args("RevoluteJoint_getTransformDerivative",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_getTransformDerivative" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RevoluteJoint_getTransformDerivative" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_getTransformDerivative" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RevoluteJoint_getTransformDerivative" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RevoluteJoint_getTransformDerivative" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RevoluteJoint_getTransformDerivative" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = ((iDynTree::RevoluteJoint const *)arg1)->getTransformDerivative((iDynTree::VectorDynSize const &)*arg2,arg3,arg4,arg5);
  _out = SWIG_NewPointerObj((new iDynTree::TransformDerivative(static_cast< const iDynTree::TransformDerivative& >(result))), SWIGTYPE_p_iDynTree__TransformDerivative, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_getMotionSubspaceVector__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  int arg2 ;
  iDynTree::LinkIndex arg3 ;
  iDynTree::LinkIndex arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("RevoluteJoint_getMotionSubspaceVector",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_getMotionSubspaceVector" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RevoluteJoint_getMotionSubspaceVector" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RevoluteJoint_getMotionSubspaceVector" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RevoluteJoint_getMotionSubspaceVector" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  result = ((iDynTree::RevoluteJoint const *)arg1)->getMotionSubspaceVector(arg2,arg3,arg4);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_getMotionSubspaceVector__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  int arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("RevoluteJoint_getMotionSubspaceVector",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_getMotionSubspaceVector" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RevoluteJoint_getMotionSubspaceVector" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RevoluteJoint_getMotionSubspaceVector" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  result = ((iDynTree::RevoluteJoint const *)arg1)->getMotionSubspaceVector(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_getMotionSubspaceVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__RevoluteJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RevoluteJoint_getMotionSubspaceVector__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__RevoluteJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_ptrdiff_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_RevoluteJoint_getMotionSubspaceVector__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'RevoluteJoint_getMotionSubspaceVector'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::RevoluteJoint::getMotionSubspaceVector(int,iDynTree::LinkIndex const,iDynTree::LinkIndex const) const\n"
    "    iDynTree::RevoluteJoint::getMotionSubspaceVector(int,iDynTree::LinkIndex const) const\n");
  return 1;
}


int _wrap_RevoluteJoint_computeChildPosVelAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  iDynTree::LinkPositions *arg5 = 0 ;
  iDynTree::LinkVelArray *arg6 = 0 ;
  iDynTree::LinkAccArray *arg7 = 0 ;
  iDynTree::LinkIndex arg8 ;
  iDynTree::LinkIndex arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  ptrdiff_t val8 ;
  int ecode8 = 0 ;
  ptrdiff_t val9 ;
  int ecode9 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RevoluteJoint_computeChildPosVelAcc",argc,9,9,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkPositions,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "5"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "5"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkPositions * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "6"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "6"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkVelArray * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "7"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "7"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::LinkAccArray * >(argp7);
  ecode8 = SWIG_AsVal_ptrdiff_t(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "8"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg8 = static_cast< iDynTree::LinkIndex >(val8);
  ecode9 = SWIG_AsVal_ptrdiff_t(argv[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "RevoluteJoint_computeChildPosVelAcc" "', argument " "9"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg9 = static_cast< iDynTree::LinkIndex >(val9);
  ((iDynTree::RevoluteJoint const *)arg1)->computeChildPosVelAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::VectorDynSize const &)*arg4,*arg5,*arg6,*arg7,arg8,arg9);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_computeChildVel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::LinkIndex arg5 ;
  iDynTree::LinkIndex arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  ptrdiff_t val6 ;
  int ecode6 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RevoluteJoint_computeChildVel",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_computeChildVel" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RevoluteJoint_computeChildVel" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildVel" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RevoluteJoint_computeChildVel" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildVel" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RevoluteJoint_computeChildVel" "', argument " "4"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildVel" "', argument " "4"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RevoluteJoint_computeChildVel" "', argument " "5"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg5 = static_cast< iDynTree::LinkIndex >(val5);
  ecode6 = SWIG_AsVal_ptrdiff_t(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RevoluteJoint_computeChildVel" "', argument " "6"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg6 = static_cast< iDynTree::LinkIndex >(val6);
  ((iDynTree::RevoluteJoint const *)arg1)->computeChildVel((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,*arg4,arg5,arg6);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_computeChildVelAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  iDynTree::LinkVelArray *arg5 = 0 ;
  iDynTree::LinkAccArray *arg6 = 0 ;
  iDynTree::LinkIndex arg7 ;
  iDynTree::LinkIndex arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  ptrdiff_t val7 ;
  int ecode7 = 0 ;
  ptrdiff_t val8 ;
  int ecode8 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RevoluteJoint_computeChildVelAcc",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_computeChildVelAcc" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RevoluteJoint_computeChildVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RevoluteJoint_computeChildVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RevoluteJoint_computeChildVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RevoluteJoint_computeChildVelAcc" "', argument " "5"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildVelAcc" "', argument " "5"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkVelArray * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "RevoluteJoint_computeChildVelAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildVelAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkAccArray * >(argp6);
  ecode7 = SWIG_AsVal_ptrdiff_t(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "RevoluteJoint_computeChildVelAcc" "', argument " "7"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg7 = static_cast< iDynTree::LinkIndex >(val7);
  ecode8 = SWIG_AsVal_ptrdiff_t(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "RevoluteJoint_computeChildVelAcc" "', argument " "8"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg8 = static_cast< iDynTree::LinkIndex >(val8);
  ((iDynTree::RevoluteJoint const *)arg1)->computeChildVelAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::VectorDynSize const &)*arg4,*arg5,*arg6,arg7,arg8);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_computeChildAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::VectorDynSize *arg5 = 0 ;
  iDynTree::LinkAccArray *arg6 = 0 ;
  iDynTree::LinkIndex arg7 ;
  iDynTree::LinkIndex arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  ptrdiff_t val7 ;
  int ecode7 = 0 ;
  ptrdiff_t val8 ;
  int ecode8 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RevoluteJoint_computeChildAcc",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_computeChildAcc" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RevoluteJoint_computeChildAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RevoluteJoint_computeChildAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RevoluteJoint_computeChildAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RevoluteJoint_computeChildAcc" "', argument " "5"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildAcc" "', argument " "5"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::VectorDynSize * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "RevoluteJoint_computeChildAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkAccArray * >(argp6);
  ecode7 = SWIG_AsVal_ptrdiff_t(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "RevoluteJoint_computeChildAcc" "', argument " "7"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg7 = static_cast< iDynTree::LinkIndex >(val7);
  ecode8 = SWIG_AsVal_ptrdiff_t(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "RevoluteJoint_computeChildAcc" "', argument " "8"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg8 = static_cast< iDynTree::LinkIndex >(val8);
  ((iDynTree::RevoluteJoint const *)arg1)->computeChildAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::LinkVelArray const &)*arg4,(iDynTree::VectorDynSize const &)*arg5,*arg6,arg7,arg8);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_computeChildBiasAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::LinkAccArray *arg5 = 0 ;
  iDynTree::LinkIndex arg6 ;
  iDynTree::LinkIndex arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ptrdiff_t val6 ;
  int ecode6 = 0 ;
  ptrdiff_t val7 ;
  int ecode7 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RevoluteJoint_computeChildBiasAcc",argc,7,7,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_computeChildBiasAcc" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RevoluteJoint_computeChildBiasAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildBiasAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RevoluteJoint_computeChildBiasAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildBiasAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RevoluteJoint_computeChildBiasAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildBiasAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RevoluteJoint_computeChildBiasAcc" "', argument " "5"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeChildBiasAcc" "', argument " "5"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkAccArray * >(argp5);
  ecode6 = SWIG_AsVal_ptrdiff_t(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "RevoluteJoint_computeChildBiasAcc" "', argument " "6"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg6 = static_cast< iDynTree::LinkIndex >(val6);
  ecode7 = SWIG_AsVal_ptrdiff_t(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "RevoluteJoint_computeChildBiasAcc" "', argument " "7"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg7 = static_cast< iDynTree::LinkIndex >(val7);
  ((iDynTree::RevoluteJoint const *)arg1)->computeChildBiasAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::LinkVelArray const &)*arg4,*arg5,arg6,arg7);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_computeJointTorque(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::Wrench *arg3 = 0 ;
  iDynTree::LinkIndex arg4 ;
  iDynTree::LinkIndex arg5 ;
  iDynTree::VectorDynSize *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("RevoluteJoint_computeJointTorque",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_computeJointTorque" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RevoluteJoint_computeJointTorque" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeJointTorque" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RevoluteJoint_computeJointTorque" "', argument " "3"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeJointTorque" "', argument " "3"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Wrench * >(argp3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RevoluteJoint_computeJointTorque" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "RevoluteJoint_computeJointTorque" "', argument " "5"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg5 = static_cast< iDynTree::LinkIndex >(val5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "RevoluteJoint_computeJointTorque" "', argument " "6"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_computeJointTorque" "', argument " "6"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::VectorDynSize * >(argp6);
  ((iDynTree::RevoluteJoint const *)arg1)->computeJointTorque((iDynTree::VectorDynSize const &)*arg2,(iDynTree::Wrench const &)*arg3,arg4,arg5,*arg6);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_hasPosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("RevoluteJoint_hasPosLimits",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_hasPosLimits" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  result = (bool)((iDynTree::RevoluteJoint const *)arg1)->hasPosLimits();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_enablePosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("RevoluteJoint_enablePosLimits",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_enablePosLimits" "', argument " "1"" of type '" "iDynTree::RevoluteJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RevoluteJoint_enablePosLimits" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->enablePosLimits(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_getPosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  size_t arg2 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("RevoluteJoint_getPosLimits",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_getPosLimits" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RevoluteJoint_getPosLimits" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RevoluteJoint_getPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_getPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RevoluteJoint_getPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_getPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  result = (bool)((iDynTree::RevoluteJoint const *)arg1)->getPosLimits(arg2,*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_getMinPosLimit(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("RevoluteJoint_getMinPosLimit",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_getMinPosLimit" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RevoluteJoint_getMinPosLimit" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (double)((iDynTree::RevoluteJoint const *)arg1)->getMinPosLimit(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_getMaxPosLimit(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("RevoluteJoint_getMaxPosLimit",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_getMaxPosLimit" "', argument " "1"" of type '" "iDynTree::RevoluteJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RevoluteJoint_getMaxPosLimit" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (double)((iDynTree::RevoluteJoint const *)arg1)->getMaxPosLimit(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RevoluteJoint_setPosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::RevoluteJoint *arg1 = (iDynTree::RevoluteJoint *) 0 ;
  size_t arg2 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("RevoluteJoint_setPosLimits",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__RevoluteJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RevoluteJoint_setPosLimits" "', argument " "1"" of type '" "iDynTree::RevoluteJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::RevoluteJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RevoluteJoint_setPosLimits" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RevoluteJoint_setPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_setPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RevoluteJoint_setPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RevoluteJoint_setPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  result = (bool)(arg1)->setPosLimits(arg2,*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_PrismaticJoint__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::PrismaticJoint *result = 0 ;
  
  if (!SWIG_check_num_args("new_PrismaticJoint",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::PrismaticJoint *)new iDynTree::PrismaticJoint();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__PrismaticJoint, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_PrismaticJoint__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkIndex arg1 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::Transform *arg3 = 0 ;
  iDynTree::Axis *arg4 = 0 ;
  ptrdiff_t val1 ;
  int ecode1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  iDynTree::PrismaticJoint *result = 0 ;
  
  if (!SWIG_check_num_args("new_PrismaticJoint",argc,4,4,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_ptrdiff_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PrismaticJoint" "', argument " "1"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg1 = static_cast< iDynTree::LinkIndex >(val1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PrismaticJoint" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_PrismaticJoint" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PrismaticJoint" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Axis,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_PrismaticJoint" "', argument " "4"" of type '" "iDynTree::Axis const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PrismaticJoint" "', argument " "4"" of type '" "iDynTree::Axis const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Axis * >(argp4);
  result = (iDynTree::PrismaticJoint *)new iDynTree::PrismaticJoint(arg1,arg2,(iDynTree::Transform const &)*arg3,(iDynTree::Axis const &)*arg4);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__PrismaticJoint, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_PrismaticJoint__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::PrismaticJoint *result = 0 ;
  
  if (!SWIG_check_num_args("new_PrismaticJoint",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__PrismaticJoint,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PrismaticJoint" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PrismaticJoint" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  result = (iDynTree::PrismaticJoint *)new iDynTree::PrismaticJoint((iDynTree::PrismaticJoint const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__PrismaticJoint, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_PrismaticJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_PrismaticJoint__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__PrismaticJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PrismaticJoint__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_ptrdiff_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Axis, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_PrismaticJoint__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_PrismaticJoint'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::PrismaticJoint::PrismaticJoint()\n"
    "    iDynTree::PrismaticJoint::PrismaticJoint(iDynTree::LinkIndex const,iDynTree::LinkIndex const,iDynTree::Transform const &,iDynTree::Axis const &)\n"
    "    iDynTree::PrismaticJoint::PrismaticJoint(iDynTree::PrismaticJoint const &)\n");
  return 1;
}


int _wrap_delete_PrismaticJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_PrismaticJoint",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PrismaticJoint" "', argument " "1"" of type '" "iDynTree::PrismaticJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::IJoint *result = 0 ;
  
  if (!SWIG_check_num_args("PrismaticJoint_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_clone" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  result = (iDynTree::IJoint *)((iDynTree::PrismaticJoint const *)arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_setAttachedLinks(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("PrismaticJoint_setAttachedLinks",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_setAttachedLinks" "', argument " "1"" of type '" "iDynTree::PrismaticJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PrismaticJoint_setAttachedLinks" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PrismaticJoint_setAttachedLinks" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  (arg1)->setAttachedLinks(arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_setRestTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("PrismaticJoint_setRestTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_setRestTransform" "', argument " "1"" of type '" "iDynTree::PrismaticJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrismaticJoint_setRestTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_setRestTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  (arg1)->setRestTransform((iDynTree::Transform const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_setAxis__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::Axis *arg2 = 0 ;
  iDynTree::LinkIndex arg3 ;
  iDynTree::LinkIndex arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("PrismaticJoint_setAxis",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_setAxis" "', argument " "1"" of type '" "iDynTree::PrismaticJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Axis,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrismaticJoint_setAxis" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_setAxis" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Axis * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PrismaticJoint_setAxis" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PrismaticJoint_setAxis" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  (arg1)->setAxis((iDynTree::Axis const &)*arg2,arg3,arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_setAxis__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::Axis *arg2 = 0 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("PrismaticJoint_setAxis",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_setAxis" "', argument " "1"" of type '" "iDynTree::PrismaticJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Axis,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrismaticJoint_setAxis" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_setAxis" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Axis * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PrismaticJoint_setAxis" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  (arg1)->setAxis((iDynTree::Axis const &)*arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_setAxis__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::Axis *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("PrismaticJoint_setAxis",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_setAxis" "', argument " "1"" of type '" "iDynTree::PrismaticJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Axis,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrismaticJoint_setAxis" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_setAxis" "', argument " "2"" of type '" "iDynTree::Axis const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Axis * >(argp2);
  (arg1)->setAxis((iDynTree::Axis const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_setAxis(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__PrismaticJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PrismaticJoint_setAxis__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__PrismaticJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PrismaticJoint_setAxis__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__PrismaticJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Axis, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_ptrdiff_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_PrismaticJoint_setAxis__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'PrismaticJoint_setAxis'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::PrismaticJoint::setAxis(iDynTree::Axis const &,iDynTree::LinkIndex const,iDynTree::LinkIndex const)\n"
    "    iDynTree::PrismaticJoint::setAxis(iDynTree::Axis const &,iDynTree::LinkIndex const)\n"
    "    iDynTree::PrismaticJoint::setAxis(iDynTree::Axis const &)\n");
  return 1;
}


int _wrap_PrismaticJoint_getFirstAttachedLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("PrismaticJoint_getFirstAttachedLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_getFirstAttachedLink" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  result = ((iDynTree::PrismaticJoint const *)arg1)->getFirstAttachedLink();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_getSecondAttachedLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("PrismaticJoint_getSecondAttachedLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_getSecondAttachedLink" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  result = ((iDynTree::PrismaticJoint const *)arg1)->getSecondAttachedLink();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_getAxis__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::Axis result;
  
  if (!SWIG_check_num_args("PrismaticJoint_getAxis",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_getAxis" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PrismaticJoint_getAxis" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PrismaticJoint_getAxis" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  result = ((iDynTree::PrismaticJoint const *)arg1)->getAxis(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Axis(static_cast< const iDynTree::Axis& >(result))), SWIGTYPE_p_iDynTree__Axis, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_getAxis__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Axis result;
  
  if (!SWIG_check_num_args("PrismaticJoint_getAxis",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_getAxis" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PrismaticJoint_getAxis" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = ((iDynTree::PrismaticJoint const *)arg1)->getAxis(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Axis(static_cast< const iDynTree::Axis& >(result))), SWIGTYPE_p_iDynTree__Axis, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_getAxis(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__PrismaticJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PrismaticJoint_getAxis__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__PrismaticJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PrismaticJoint_getAxis__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'PrismaticJoint_getAxis'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::PrismaticJoint::getAxis(iDynTree::LinkIndex const,iDynTree::LinkIndex const) const\n"
    "    iDynTree::PrismaticJoint::getAxis(iDynTree::LinkIndex const) const\n");
  return 1;
}


int _wrap_PrismaticJoint_getRestTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("PrismaticJoint_getRestTransform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_getRestTransform" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PrismaticJoint_getRestTransform" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PrismaticJoint_getRestTransform" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  result = ((iDynTree::PrismaticJoint const *)arg1)->getRestTransform(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_getTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::LinkIndex arg3 ;
  iDynTree::LinkIndex arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  iDynTree::Transform *result = 0 ;
  
  if (!SWIG_check_num_args("PrismaticJoint_getTransform",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_getTransform" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrismaticJoint_getTransform" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_getTransform" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PrismaticJoint_getTransform" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PrismaticJoint_getTransform" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  result = (iDynTree::Transform *) &((iDynTree::PrismaticJoint const *)arg1)->getTransform((iDynTree::VectorDynSize const &)*arg2,arg3,arg4);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_getTransformDerivative(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::LinkIndex arg3 ;
  iDynTree::LinkIndex arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  mxArray * _out;
  iDynTree::TransformDerivative result;
  
  if (!SWIG_check_num_args("PrismaticJoint_getTransformDerivative",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_getTransformDerivative" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrismaticJoint_getTransformDerivative" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_getTransformDerivative" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PrismaticJoint_getTransformDerivative" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PrismaticJoint_getTransformDerivative" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PrismaticJoint_getTransformDerivative" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  result = ((iDynTree::PrismaticJoint const *)arg1)->getTransformDerivative((iDynTree::VectorDynSize const &)*arg2,arg3,arg4,arg5);
  _out = SWIG_NewPointerObj((new iDynTree::TransformDerivative(static_cast< const iDynTree::TransformDerivative& >(result))), SWIGTYPE_p_iDynTree__TransformDerivative, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_getMotionSubspaceVector__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  int arg2 ;
  iDynTree::LinkIndex arg3 ;
  iDynTree::LinkIndex arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("PrismaticJoint_getMotionSubspaceVector",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_getMotionSubspaceVector" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PrismaticJoint_getMotionSubspaceVector" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PrismaticJoint_getMotionSubspaceVector" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PrismaticJoint_getMotionSubspaceVector" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  result = ((iDynTree::PrismaticJoint const *)arg1)->getMotionSubspaceVector(arg2,arg3,arg4);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_getMotionSubspaceVector__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  int arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector result;
  
  if (!SWIG_check_num_args("PrismaticJoint_getMotionSubspaceVector",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_getMotionSubspaceVector" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PrismaticJoint_getMotionSubspaceVector" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PrismaticJoint_getMotionSubspaceVector" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  result = ((iDynTree::PrismaticJoint const *)arg1)->getMotionSubspaceVector(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMotionVector(static_cast< const iDynTree::SpatialMotionVector& >(result))), SWIGTYPE_p_iDynTree__SpatialMotionVector, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_getMotionSubspaceVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__PrismaticJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PrismaticJoint_getMotionSubspaceVector__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__PrismaticJoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_ptrdiff_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_PrismaticJoint_getMotionSubspaceVector__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'PrismaticJoint_getMotionSubspaceVector'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::PrismaticJoint::getMotionSubspaceVector(int,iDynTree::LinkIndex const,iDynTree::LinkIndex const) const\n"
    "    iDynTree::PrismaticJoint::getMotionSubspaceVector(int,iDynTree::LinkIndex const) const\n");
  return 1;
}


int _wrap_PrismaticJoint_computeChildPosVelAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  iDynTree::LinkPositions *arg5 = 0 ;
  iDynTree::LinkVelArray *arg6 = 0 ;
  iDynTree::LinkAccArray *arg7 = 0 ;
  iDynTree::LinkIndex arg8 ;
  iDynTree::LinkIndex arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  ptrdiff_t val8 ;
  int ecode8 = 0 ;
  ptrdiff_t val9 ;
  int ecode9 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("PrismaticJoint_computeChildPosVelAcc",argc,9,9,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkPositions,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "5"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "5"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkPositions * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "6"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "6"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkVelArray * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "7"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "7"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::LinkAccArray * >(argp7);
  ecode8 = SWIG_AsVal_ptrdiff_t(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "8"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg8 = static_cast< iDynTree::LinkIndex >(val8);
  ecode9 = SWIG_AsVal_ptrdiff_t(argv[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "PrismaticJoint_computeChildPosVelAcc" "', argument " "9"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg9 = static_cast< iDynTree::LinkIndex >(val9);
  ((iDynTree::PrismaticJoint const *)arg1)->computeChildPosVelAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::VectorDynSize const &)*arg4,*arg5,*arg6,*arg7,arg8,arg9);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_computeChildVel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::LinkIndex arg5 ;
  iDynTree::LinkIndex arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  ptrdiff_t val6 ;
  int ecode6 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("PrismaticJoint_computeChildVel",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_computeChildVel" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrismaticJoint_computeChildVel" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildVel" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PrismaticJoint_computeChildVel" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildVel" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PrismaticJoint_computeChildVel" "', argument " "4"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildVel" "', argument " "4"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PrismaticJoint_computeChildVel" "', argument " "5"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg5 = static_cast< iDynTree::LinkIndex >(val5);
  ecode6 = SWIG_AsVal_ptrdiff_t(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PrismaticJoint_computeChildVel" "', argument " "6"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg6 = static_cast< iDynTree::LinkIndex >(val6);
  ((iDynTree::PrismaticJoint const *)arg1)->computeChildVel((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,*arg4,arg5,arg6);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_computeChildVelAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  iDynTree::LinkVelArray *arg5 = 0 ;
  iDynTree::LinkAccArray *arg6 = 0 ;
  iDynTree::LinkIndex arg7 ;
  iDynTree::LinkIndex arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  ptrdiff_t val7 ;
  int ecode7 = 0 ;
  ptrdiff_t val8 ;
  int ecode8 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("PrismaticJoint_computeChildVelAcc",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_computeChildVelAcc" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrismaticJoint_computeChildVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildVelAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PrismaticJoint_computeChildVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildVelAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PrismaticJoint_computeChildVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildVelAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PrismaticJoint_computeChildVelAcc" "', argument " "5"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildVelAcc" "', argument " "5"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkVelArray * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "PrismaticJoint_computeChildVelAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildVelAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkAccArray * >(argp6);
  ecode7 = SWIG_AsVal_ptrdiff_t(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PrismaticJoint_computeChildVelAcc" "', argument " "7"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg7 = static_cast< iDynTree::LinkIndex >(val7);
  ecode8 = SWIG_AsVal_ptrdiff_t(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "PrismaticJoint_computeChildVelAcc" "', argument " "8"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg8 = static_cast< iDynTree::LinkIndex >(val8);
  ((iDynTree::PrismaticJoint const *)arg1)->computeChildVelAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::VectorDynSize const &)*arg4,*arg5,*arg6,arg7,arg8);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_computeChildAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::VectorDynSize *arg5 = 0 ;
  iDynTree::LinkAccArray *arg6 = 0 ;
  iDynTree::LinkIndex arg7 ;
  iDynTree::LinkIndex arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  ptrdiff_t val7 ;
  int ecode7 = 0 ;
  ptrdiff_t val8 ;
  int ecode8 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("PrismaticJoint_computeChildAcc",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_computeChildAcc" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrismaticJoint_computeChildAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PrismaticJoint_computeChildAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PrismaticJoint_computeChildAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PrismaticJoint_computeChildAcc" "', argument " "5"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildAcc" "', argument " "5"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::VectorDynSize * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "PrismaticJoint_computeChildAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildAcc" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkAccArray * >(argp6);
  ecode7 = SWIG_AsVal_ptrdiff_t(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PrismaticJoint_computeChildAcc" "', argument " "7"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg7 = static_cast< iDynTree::LinkIndex >(val7);
  ecode8 = SWIG_AsVal_ptrdiff_t(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "PrismaticJoint_computeChildAcc" "', argument " "8"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg8 = static_cast< iDynTree::LinkIndex >(val8);
  ((iDynTree::PrismaticJoint const *)arg1)->computeChildAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::LinkVelArray const &)*arg4,(iDynTree::VectorDynSize const &)*arg5,*arg6,arg7,arg8);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_computeChildBiasAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::LinkAccArray *arg5 = 0 ;
  iDynTree::LinkIndex arg6 ;
  iDynTree::LinkIndex arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  ptrdiff_t val6 ;
  int ecode6 = 0 ;
  ptrdiff_t val7 ;
  int ecode7 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("PrismaticJoint_computeChildBiasAcc",argc,7,7,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_computeChildBiasAcc" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrismaticJoint_computeChildBiasAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildBiasAcc" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PrismaticJoint_computeChildBiasAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildBiasAcc" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PrismaticJoint_computeChildBiasAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildBiasAcc" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PrismaticJoint_computeChildBiasAcc" "', argument " "5"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeChildBiasAcc" "', argument " "5"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkAccArray * >(argp5);
  ecode6 = SWIG_AsVal_ptrdiff_t(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "PrismaticJoint_computeChildBiasAcc" "', argument " "6"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg6 = static_cast< iDynTree::LinkIndex >(val6);
  ecode7 = SWIG_AsVal_ptrdiff_t(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PrismaticJoint_computeChildBiasAcc" "', argument " "7"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg7 = static_cast< iDynTree::LinkIndex >(val7);
  ((iDynTree::PrismaticJoint const *)arg1)->computeChildBiasAcc((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::LinkVelArray const &)*arg4,*arg5,arg6,arg7);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_computeJointTorque(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::Wrench *arg3 = 0 ;
  iDynTree::LinkIndex arg4 ;
  iDynTree::LinkIndex arg5 ;
  iDynTree::VectorDynSize *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("PrismaticJoint_computeJointTorque",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_computeJointTorque" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrismaticJoint_computeJointTorque" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeJointTorque" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PrismaticJoint_computeJointTorque" "', argument " "3"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeJointTorque" "', argument " "3"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Wrench * >(argp3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PrismaticJoint_computeJointTorque" "', argument " "4"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg4 = static_cast< iDynTree::LinkIndex >(val4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PrismaticJoint_computeJointTorque" "', argument " "5"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg5 = static_cast< iDynTree::LinkIndex >(val5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "PrismaticJoint_computeJointTorque" "', argument " "6"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_computeJointTorque" "', argument " "6"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::VectorDynSize * >(argp6);
  ((iDynTree::PrismaticJoint const *)arg1)->computeJointTorque((iDynTree::VectorDynSize const &)*arg2,(iDynTree::Wrench const &)*arg3,arg4,arg5,*arg6);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_hasPosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("PrismaticJoint_hasPosLimits",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_hasPosLimits" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  result = (bool)((iDynTree::PrismaticJoint const *)arg1)->hasPosLimits();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_enablePosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("PrismaticJoint_enablePosLimits",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_enablePosLimits" "', argument " "1"" of type '" "iDynTree::PrismaticJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PrismaticJoint_enablePosLimits" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->enablePosLimits(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_getPosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  size_t arg2 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("PrismaticJoint_getPosLimits",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_getPosLimits" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PrismaticJoint_getPosLimits" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PrismaticJoint_getPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_getPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PrismaticJoint_getPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_getPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  result = (bool)((iDynTree::PrismaticJoint const *)arg1)->getPosLimits(arg2,*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_getMinPosLimit(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("PrismaticJoint_getMinPosLimit",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_getMinPosLimit" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PrismaticJoint_getMinPosLimit" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (double)((iDynTree::PrismaticJoint const *)arg1)->getMinPosLimit(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_getMaxPosLimit(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("PrismaticJoint_getMaxPosLimit",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_getMaxPosLimit" "', argument " "1"" of type '" "iDynTree::PrismaticJoint const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PrismaticJoint_getMaxPosLimit" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (double)((iDynTree::PrismaticJoint const *)arg1)->getMaxPosLimit(arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PrismaticJoint_setPosLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PrismaticJoint *arg1 = (iDynTree::PrismaticJoint *) 0 ;
  size_t arg2 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("PrismaticJoint_setPosLimits",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PrismaticJoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrismaticJoint_setPosLimits" "', argument " "1"" of type '" "iDynTree::PrismaticJoint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PrismaticJoint * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PrismaticJoint_setPosLimits" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PrismaticJoint_setPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_setPosLimits" "', argument " "3"" of type '" "double &""'"); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PrismaticJoint_setPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrismaticJoint_setPosLimits" "', argument " "4"" of type '" "double &""'"); 
  }
  arg4 = reinterpret_cast< double * >(argp4);
  result = (bool)(arg1)->setPosLimits(arg2,*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Traversal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Traversal *result = 0 ;
  
  if (!SWIG_check_num_args("new_Traversal",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Traversal *)new iDynTree::Traversal();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Traversal, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Traversal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Traversal",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Traversal" "', argument " "1"" of type '" "iDynTree::Traversal *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_getNrOfVisitedLinks(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("Traversal_getNrOfVisitedLinks",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_getNrOfVisitedLinks" "', argument " "1"" of type '" "iDynTree::Traversal const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  result = (unsigned int)((iDynTree::Traversal const *)arg1)->getNrOfVisitedLinks();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_getLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  iDynTree::TraversalIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Link *result = 0 ;
  
  if (!SWIG_check_num_args("Traversal_getLink",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_getLink" "', argument " "1"" of type '" "iDynTree::Traversal const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Traversal_getLink" "', argument " "2"" of type '" "iDynTree::TraversalIndex""'");
  } 
  arg2 = static_cast< iDynTree::TraversalIndex >(val2);
  result = (iDynTree::Link *)((iDynTree::Traversal const *)arg1)->getLink(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_getBaseLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Link *result = 0 ;
  
  if (!SWIG_check_num_args("Traversal_getBaseLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_getBaseLink" "', argument " "1"" of type '" "iDynTree::Traversal const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  result = (iDynTree::Link *)((iDynTree::Traversal const *)arg1)->getBaseLink();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_getParentLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  iDynTree::TraversalIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Link *result = 0 ;
  
  if (!SWIG_check_num_args("Traversal_getParentLink",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_getParentLink" "', argument " "1"" of type '" "iDynTree::Traversal const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Traversal_getParentLink" "', argument " "2"" of type '" "iDynTree::TraversalIndex""'");
  } 
  arg2 = static_cast< iDynTree::TraversalIndex >(val2);
  result = (iDynTree::Link *)((iDynTree::Traversal const *)arg1)->getParentLink(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_getParentJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  iDynTree::TraversalIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::IJoint *result = 0 ;
  
  if (!SWIG_check_num_args("Traversal_getParentJoint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_getParentJoint" "', argument " "1"" of type '" "iDynTree::Traversal const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Traversal_getParentJoint" "', argument " "2"" of type '" "iDynTree::TraversalIndex""'");
  } 
  arg2 = static_cast< iDynTree::TraversalIndex >(val2);
  result = (iDynTree::IJoint *)((iDynTree::Traversal const *)arg1)->getParentJoint(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_getParentLinkFromLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Link *result = 0 ;
  
  if (!SWIG_check_num_args("Traversal_getParentLinkFromLinkIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_getParentLinkFromLinkIndex" "', argument " "1"" of type '" "iDynTree::Traversal const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Traversal_getParentLinkFromLinkIndex" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::Link *)((iDynTree::Traversal const *)arg1)->getParentLinkFromLinkIndex(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_getParentJointFromLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::IJoint *result = 0 ;
  
  if (!SWIG_check_num_args("Traversal_getParentJointFromLinkIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_getParentJointFromLinkIndex" "', argument " "1"" of type '" "iDynTree::Traversal const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Traversal_getParentJointFromLinkIndex" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::IJoint *)((iDynTree::Traversal const *)arg1)->getParentJointFromLinkIndex(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_getTraversalIndexFromLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::TraversalIndex result;
  
  if (!SWIG_check_num_args("Traversal_getTraversalIndexFromLinkIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_getTraversalIndexFromLinkIndex" "', argument " "1"" of type '" "iDynTree::Traversal const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Traversal_getTraversalIndexFromLinkIndex" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = ((iDynTree::Traversal const *)arg1)->getTraversalIndexFromLinkIndex(arg2);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_reset__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Traversal_reset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_reset" "', argument " "1"" of type '" "iDynTree::Traversal *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Traversal_reset" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (bool)(arg1)->reset(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_reset__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Traversal_reset",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_reset" "', argument " "1"" of type '" "iDynTree::Traversal *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Traversal_reset" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Traversal_reset" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)(arg1)->reset((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_reset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Traversal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Traversal_reset__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Traversal, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Traversal_reset__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Traversal_reset'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Traversal::reset(unsigned int const)\n"
    "    iDynTree::Traversal::reset(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_Traversal_addTraversalBase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  iDynTree::Link *arg2 = (iDynTree::Link *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Traversal_addTraversalBase",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_addTraversalBase" "', argument " "1"" of type '" "iDynTree::Traversal *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Traversal_addTraversalBase" "', argument " "2"" of type '" "iDynTree::Link const *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Link * >(argp2);
  result = (bool)(arg1)->addTraversalBase((iDynTree::Link const *)arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_addTraversalElement(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  iDynTree::Link *arg2 = (iDynTree::Link *) 0 ;
  iDynTree::IJoint *arg3 = (iDynTree::IJoint *) 0 ;
  iDynTree::Link *arg4 = (iDynTree::Link *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Traversal_addTraversalElement",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_addTraversalElement" "', argument " "1"" of type '" "iDynTree::Traversal *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Traversal_addTraversalElement" "', argument " "2"" of type '" "iDynTree::Link const *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Link * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Traversal_addTraversalElement" "', argument " "3"" of type '" "iDynTree::IJoint const *""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::IJoint * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Traversal_addTraversalElement" "', argument " "4"" of type '" "iDynTree::Link const *""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Link * >(argp4);
  result = (bool)(arg1)->addTraversalElement((iDynTree::Link const *)arg2,(iDynTree::IJoint const *)arg3,(iDynTree::Link const *)arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_isParentOf(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Traversal_isParentOf",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_isParentOf" "', argument " "1"" of type '" "iDynTree::Traversal const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Traversal_isParentOf" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Traversal_isParentOf" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  result = (bool)((iDynTree::Traversal const *)arg1)->isParentOf(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_getChildLinkIndexFromJointIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  iDynTree::JointIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("Traversal_getChildLinkIndexFromJointIndex",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_getChildLinkIndexFromJointIndex" "', argument " "1"" of type '" "iDynTree::Traversal const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Traversal_getChildLinkIndexFromJointIndex" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Traversal_getChildLinkIndexFromJointIndex" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Traversal_getChildLinkIndexFromJointIndex" "', argument " "3"" of type '" "iDynTree::JointIndex""'");
  } 
  arg3 = static_cast< iDynTree::JointIndex >(val3);
  result = ((iDynTree::Traversal const *)arg1)->getChildLinkIndexFromJointIndex((iDynTree::Model const &)*arg2,arg3);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_getParentLinkIndexFromJointIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  iDynTree::JointIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("Traversal_getParentLinkIndexFromJointIndex",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_getParentLinkIndexFromJointIndex" "', argument " "1"" of type '" "iDynTree::Traversal const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Traversal_getParentLinkIndexFromJointIndex" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Traversal_getParentLinkIndexFromJointIndex" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Traversal_getParentLinkIndexFromJointIndex" "', argument " "3"" of type '" "iDynTree::JointIndex""'");
  } 
  arg3 = static_cast< iDynTree::JointIndex >(val3);
  result = ((iDynTree::Traversal const *)arg1)->getParentLinkIndexFromJointIndex((iDynTree::Model const &)*arg2,arg3);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Traversal_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Traversal *arg1 = (iDynTree::Traversal *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Traversal_toString",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Traversal_toString" "', argument " "1"" of type '" "iDynTree::Traversal const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Traversal * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Traversal_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Traversal_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = ((iDynTree::Traversal const *)arg1)->toString((iDynTree::Model const &)*arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Material__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Material *result = 0 ;
  
  if (!SWIG_check_num_args("new_Material",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Material *)new iDynTree::Material();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Material, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Material__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  mxArray * _out;
  iDynTree::Material *result = 0 ;
  
  if (!SWIG_check_num_args("new_Material",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Material" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Material" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  result = (iDynTree::Material *)new iDynTree::Material((std::string const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Material, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 0;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 1;
}


int _wrap_new_Material(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Material__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Material__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Material'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Material::Material()\n"
    "    iDynTree::Material::Material(std::string const &)\n");
  return 1;
}


int _wrap_Material_name(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Material *arg1 = (iDynTree::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Material_name",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_name" "', argument " "1"" of type '" "iDynTree::Material const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Material * >(argp1);
  result = ((iDynTree::Material const *)arg1)->name();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Material_hasColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Material *arg1 = (iDynTree::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Material_hasColor",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_hasColor" "', argument " "1"" of type '" "iDynTree::Material const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Material * >(argp1);
  result = (bool)((iDynTree::Material const *)arg1)->hasColor();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Material_color(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Material *arg1 = (iDynTree::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Vector4 result;
  
  if (!SWIG_check_num_args("Material_color",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_color" "', argument " "1"" of type '" "iDynTree::Material const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Material * >(argp1);
  result = ((iDynTree::Material const *)arg1)->color();
  _out = SWIG_NewPointerObj((new iDynTree::Vector4(static_cast< const iDynTree::Vector4& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Material_setColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Material *arg1 = (iDynTree::Material *) 0 ;
  iDynTree::Vector4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Material_setColor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_setColor" "', argument " "1"" of type '" "iDynTree::Material *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Material * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Material_setColor" "', argument " "2"" of type '" "iDynTree::Vector4 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Material_setColor" "', argument " "2"" of type '" "iDynTree::Vector4 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector4 * >(argp2);
  (arg1)->setColor((iDynTree::Vector4 const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Material_hasTexture(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Material *arg1 = (iDynTree::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Material_hasTexture",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_hasTexture" "', argument " "1"" of type '" "iDynTree::Material const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Material * >(argp1);
  result = (bool)((iDynTree::Material const *)arg1)->hasTexture();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Material_texture(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Material *arg1 = (iDynTree::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Material_texture",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_texture" "', argument " "1"" of type '" "iDynTree::Material const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Material * >(argp1);
  result = ((iDynTree::Material const *)arg1)->texture();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Material_setTexture(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Material *arg1 = (iDynTree::Material *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Material_setTexture",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Material_setTexture" "', argument " "1"" of type '" "iDynTree::Material *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Material * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Material_setTexture" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Material_setTexture" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->setTexture((std::string const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_delete_Material(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Material *arg1 = (iDynTree::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Material",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Material, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Material" "', argument " "1"" of type '" "iDynTree::Material *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Material * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_SolidShape(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SolidShape",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SolidShape" "', argument " "1"" of type '" "iDynTree::SolidShape *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SolidShape *result = 0 ;
  
  if (!SWIG_check_num_args("SolidShape_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_clone" "', argument " "1"" of type '" "iDynTree::SolidShape *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (iDynTree::SolidShape *)(arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_getName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string *result = 0 ;
  
  if (!SWIG_check_num_args("SolidShape_getName",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_getName" "', argument " "1"" of type '" "iDynTree::SolidShape const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (std::string *) &((iDynTree::SolidShape const *)arg1)->getName();
  _out = SWIG_From_std_string(static_cast< std::string >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_setName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SolidShape_setName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_setName" "', argument " "1"" of type '" "iDynTree::SolidShape *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SolidShape_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SolidShape_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->setName((std::string const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_SolidShape_isNameValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SolidShape_isNameValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_isNameValid" "', argument " "1"" of type '" "iDynTree::SolidShape const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (bool)((iDynTree::SolidShape const *)arg1)->isNameValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_getLink_H_geometry(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform *result = 0 ;
  
  if (!SWIG_check_num_args("SolidShape_getLink_H_geometry",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_getLink_H_geometry" "', argument " "1"" of type '" "iDynTree::SolidShape const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (iDynTree::Transform *) &((iDynTree::SolidShape const *)arg1)->getLink_H_geometry();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_setLink_H_geometry(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SolidShape_setLink_H_geometry",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_setLink_H_geometry" "', argument " "1"" of type '" "iDynTree::SolidShape *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SolidShape_setLink_H_geometry" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SolidShape_setLink_H_geometry" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  (arg1)->setLink_H_geometry((iDynTree::Transform const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_isMaterialSet(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SolidShape_isMaterialSet",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_isMaterialSet" "', argument " "1"" of type '" "iDynTree::SolidShape const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (bool)((iDynTree::SolidShape const *)arg1)->isMaterialSet();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_getMaterial(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Material *result = 0 ;
  
  if (!SWIG_check_num_args("SolidShape_getMaterial",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_getMaterial" "', argument " "1"" of type '" "iDynTree::SolidShape const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (iDynTree::Material *) &((iDynTree::SolidShape const *)arg1)->getMaterial();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Material, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_setMaterial(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  iDynTree::Material *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SolidShape_setMaterial",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_setMaterial" "', argument " "1"" of type '" "iDynTree::SolidShape *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Material,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SolidShape_setMaterial" "', argument " "2"" of type '" "iDynTree::Material const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SolidShape_setMaterial" "', argument " "2"" of type '" "iDynTree::Material const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Material * >(argp2);
  (arg1)->setMaterial((iDynTree::Material const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_isSphere(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SolidShape_isSphere",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_isSphere" "', argument " "1"" of type '" "iDynTree::SolidShape const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (bool)((iDynTree::SolidShape const *)arg1)->isSphere();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_isBox(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SolidShape_isBox",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_isBox" "', argument " "1"" of type '" "iDynTree::SolidShape const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (bool)((iDynTree::SolidShape const *)arg1)->isBox();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_isCylinder(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SolidShape_isCylinder",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_isCylinder" "', argument " "1"" of type '" "iDynTree::SolidShape const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (bool)((iDynTree::SolidShape const *)arg1)->isCylinder();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_isExternalMesh(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SolidShape_isExternalMesh",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_isExternalMesh" "', argument " "1"" of type '" "iDynTree::SolidShape const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (bool)((iDynTree::SolidShape const *)arg1)->isExternalMesh();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_asSphere__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Sphere *result = 0 ;
  
  if (!SWIG_check_num_args("SolidShape_asSphere",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_asSphere" "', argument " "1"" of type '" "iDynTree::SolidShape *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (iDynTree::Sphere *)(arg1)->asSphere();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Sphere, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_asBox__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Box *result = 0 ;
  
  if (!SWIG_check_num_args("SolidShape_asBox",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_asBox" "', argument " "1"" of type '" "iDynTree::SolidShape *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (iDynTree::Box *)(arg1)->asBox();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Box, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_asCylinder__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Cylinder *result = 0 ;
  
  if (!SWIG_check_num_args("SolidShape_asCylinder",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_asCylinder" "', argument " "1"" of type '" "iDynTree::SolidShape *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (iDynTree::Cylinder *)(arg1)->asCylinder();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Cylinder, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_asExternalMesh__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ExternalMesh *result = 0 ;
  
  if (!SWIG_check_num_args("SolidShape_asExternalMesh",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_asExternalMesh" "', argument " "1"" of type '" "iDynTree::SolidShape *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (iDynTree::ExternalMesh *)(arg1)->asExternalMesh();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ExternalMesh, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_asSphere__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Sphere *result = 0 ;
  
  if (!SWIG_check_num_args("SolidShape_asSphere",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_asSphere" "', argument " "1"" of type '" "iDynTree::SolidShape const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (iDynTree::Sphere *)((iDynTree::SolidShape const *)arg1)->asSphere();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Sphere, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_asSphere(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SolidShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SolidShape_asSphere__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SolidShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SolidShape_asSphere__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SolidShape_asSphere'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SolidShape::asSphere()\n"
    "    iDynTree::SolidShape::asSphere() const\n");
  return 1;
}


int _wrap_SolidShape_asBox__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Box *result = 0 ;
  
  if (!SWIG_check_num_args("SolidShape_asBox",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_asBox" "', argument " "1"" of type '" "iDynTree::SolidShape const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (iDynTree::Box *)((iDynTree::SolidShape const *)arg1)->asBox();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Box, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_asBox(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SolidShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SolidShape_asBox__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SolidShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SolidShape_asBox__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SolidShape_asBox'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SolidShape::asBox()\n"
    "    iDynTree::SolidShape::asBox() const\n");
  return 1;
}


int _wrap_SolidShape_asCylinder__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Cylinder *result = 0 ;
  
  if (!SWIG_check_num_args("SolidShape_asCylinder",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_asCylinder" "', argument " "1"" of type '" "iDynTree::SolidShape const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (iDynTree::Cylinder *)((iDynTree::SolidShape const *)arg1)->asCylinder();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Cylinder, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_asCylinder(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SolidShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SolidShape_asCylinder__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SolidShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SolidShape_asCylinder__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SolidShape_asCylinder'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SolidShape::asCylinder()\n"
    "    iDynTree::SolidShape::asCylinder() const\n");
  return 1;
}


int _wrap_SolidShape_asExternalMesh__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = (iDynTree::SolidShape *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ExternalMesh *result = 0 ;
  
  if (!SWIG_check_num_args("SolidShape_asExternalMesh",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShape_asExternalMesh" "', argument " "1"" of type '" "iDynTree::SolidShape const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  result = (iDynTree::ExternalMesh *)((iDynTree::SolidShape const *)arg1)->asExternalMesh();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ExternalMesh, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShape_asExternalMesh(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SolidShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SolidShape_asExternalMesh__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SolidShape, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SolidShape_asExternalMesh__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SolidShape_asExternalMesh'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SolidShape::asExternalMesh()\n"
    "    iDynTree::SolidShape::asExternalMesh() const\n");
  return 1;
}


int _wrap_delete_Sphere(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Sphere *arg1 = (iDynTree::Sphere *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Sphere",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Sphere, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sphere" "', argument " "1"" of type '" "iDynTree::Sphere *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Sphere * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Sphere_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Sphere *arg1 = (iDynTree::Sphere *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SolidShape *result = 0 ;
  
  if (!SWIG_check_num_args("Sphere_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sphere_clone" "', argument " "1"" of type '" "iDynTree::Sphere *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Sphere * >(argp1);
  result = (iDynTree::SolidShape *)(arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Sphere_getRadius(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Sphere *arg1 = (iDynTree::Sphere *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Sphere_getRadius",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sphere_getRadius" "', argument " "1"" of type '" "iDynTree::Sphere const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Sphere * >(argp1);
  result = (double)((iDynTree::Sphere const *)arg1)->getRadius();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Sphere_setRadius(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Sphere *arg1 = (iDynTree::Sphere *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Sphere_setRadius",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sphere_setRadius" "', argument " "1"" of type '" "iDynTree::Sphere *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Sphere * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sphere_setRadius" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setRadius(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Sphere(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Sphere *result = 0 ;
  
  if (!SWIG_check_num_args("new_Sphere",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Sphere *)new iDynTree::Sphere();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Sphere, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Box(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Box *arg1 = (iDynTree::Box *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Box",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Box, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Box" "', argument " "1"" of type '" "iDynTree::Box *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Box * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Box_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Box *arg1 = (iDynTree::Box *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SolidShape *result = 0 ;
  
  if (!SWIG_check_num_args("Box_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Box_clone" "', argument " "1"" of type '" "iDynTree::Box *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Box * >(argp1);
  result = (iDynTree::SolidShape *)(arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Box_getX(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Box *arg1 = (iDynTree::Box *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Box_getX",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Box_getX" "', argument " "1"" of type '" "iDynTree::Box const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Box * >(argp1);
  result = (double)((iDynTree::Box const *)arg1)->getX();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Box_setX(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Box *arg1 = (iDynTree::Box *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Box_setX",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Box_setX" "', argument " "1"" of type '" "iDynTree::Box *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Box * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Box_setX" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setX(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Box_getY(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Box *arg1 = (iDynTree::Box *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Box_getY",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Box_getY" "', argument " "1"" of type '" "iDynTree::Box const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Box * >(argp1);
  result = (double)((iDynTree::Box const *)arg1)->getY();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Box_setY(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Box *arg1 = (iDynTree::Box *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Box_setY",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Box_setY" "', argument " "1"" of type '" "iDynTree::Box *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Box * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Box_setY" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setY(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Box_getZ(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Box *arg1 = (iDynTree::Box *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Box_getZ",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Box_getZ" "', argument " "1"" of type '" "iDynTree::Box const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Box * >(argp1);
  result = (double)((iDynTree::Box const *)arg1)->getZ();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Box_setZ(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Box *arg1 = (iDynTree::Box *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Box_setZ",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Box_setZ" "', argument " "1"" of type '" "iDynTree::Box *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Box * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Box_setZ" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setZ(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Box(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Box *result = 0 ;
  
  if (!SWIG_check_num_args("new_Box",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Box *)new iDynTree::Box();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Box, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Cylinder(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Cylinder *arg1 = (iDynTree::Cylinder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Cylinder",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Cylinder, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Cylinder" "', argument " "1"" of type '" "iDynTree::Cylinder *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Cylinder * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Cylinder_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Cylinder *arg1 = (iDynTree::Cylinder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SolidShape *result = 0 ;
  
  if (!SWIG_check_num_args("Cylinder_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Cylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cylinder_clone" "', argument " "1"" of type '" "iDynTree::Cylinder *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Cylinder * >(argp1);
  result = (iDynTree::SolidShape *)(arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Cylinder_getLength(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Cylinder *arg1 = (iDynTree::Cylinder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Cylinder_getLength",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Cylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cylinder_getLength" "', argument " "1"" of type '" "iDynTree::Cylinder const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Cylinder * >(argp1);
  result = (double)((iDynTree::Cylinder const *)arg1)->getLength();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Cylinder_setLength(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Cylinder *arg1 = (iDynTree::Cylinder *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Cylinder_setLength",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Cylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cylinder_setLength" "', argument " "1"" of type '" "iDynTree::Cylinder *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Cylinder * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cylinder_setLength" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setLength(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Cylinder_getRadius(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Cylinder *arg1 = (iDynTree::Cylinder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Cylinder_getRadius",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Cylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cylinder_getRadius" "', argument " "1"" of type '" "iDynTree::Cylinder const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Cylinder * >(argp1);
  result = (double)((iDynTree::Cylinder const *)arg1)->getRadius();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Cylinder_setRadius(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Cylinder *arg1 = (iDynTree::Cylinder *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Cylinder_setRadius",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Cylinder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cylinder_setRadius" "', argument " "1"" of type '" "iDynTree::Cylinder *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Cylinder * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Cylinder_setRadius" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setRadius(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Cylinder(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Cylinder *result = 0 ;
  
  if (!SWIG_check_num_args("new_Cylinder",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Cylinder *)new iDynTree::Cylinder();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Cylinder, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ExternalMesh(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExternalMesh *arg1 = (iDynTree::ExternalMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ExternalMesh",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExternalMesh, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExternalMesh" "', argument " "1"" of type '" "iDynTree::ExternalMesh *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExternalMesh * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExternalMesh_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExternalMesh *arg1 = (iDynTree::ExternalMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SolidShape *result = 0 ;
  
  if (!SWIG_check_num_args("ExternalMesh_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExternalMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExternalMesh_clone" "', argument " "1"" of type '" "iDynTree::ExternalMesh *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExternalMesh * >(argp1);
  result = (iDynTree::SolidShape *)(arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExternalMesh_getFilename(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExternalMesh *arg1 = (iDynTree::ExternalMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string *result = 0 ;
  
  if (!SWIG_check_num_args("ExternalMesh_getFilename",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExternalMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExternalMesh_getFilename" "', argument " "1"" of type '" "iDynTree::ExternalMesh const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExternalMesh * >(argp1);
  result = (std::string *) &((iDynTree::ExternalMesh const *)arg1)->getFilename();
  _out = SWIG_From_std_string(static_cast< std::string >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExternalMesh_getFileLocationOnLocalFileSystem(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExternalMesh *arg1 = (iDynTree::ExternalMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("ExternalMesh_getFileLocationOnLocalFileSystem",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExternalMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExternalMesh_getFileLocationOnLocalFileSystem" "', argument " "1"" of type '" "iDynTree::ExternalMesh const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExternalMesh * >(argp1);
  result = ((iDynTree::ExternalMesh const *)arg1)->getFileLocationOnLocalFileSystem();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExternalMesh_setFilename(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExternalMesh *arg1 = (iDynTree::ExternalMesh *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ExternalMesh_setFilename",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExternalMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExternalMesh_setFilename" "', argument " "1"" of type '" "iDynTree::ExternalMesh *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExternalMesh * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExternalMesh_setFilename" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExternalMesh_setFilename" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->setFilename((std::string const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ExternalMesh_getScale(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExternalMesh *arg1 = (iDynTree::ExternalMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Vector3 *result = 0 ;
  
  if (!SWIG_check_num_args("ExternalMesh_getScale",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExternalMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExternalMesh_getScale" "', argument " "1"" of type '" "iDynTree::ExternalMesh const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExternalMesh * >(argp1);
  result = (iDynTree::Vector3 *) &((iDynTree::ExternalMesh const *)arg1)->getScale();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExternalMesh_setScale(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExternalMesh *arg1 = (iDynTree::ExternalMesh *) 0 ;
  iDynTree::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ExternalMesh_setScale",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExternalMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExternalMesh_setScale" "', argument " "1"" of type '" "iDynTree::ExternalMesh *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExternalMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExternalMesh_setScale" "', argument " "2"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExternalMesh_setScale" "', argument " "2"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector3 * >(argp2);
  (arg1)->setScale((iDynTree::Vector3 const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ExternalMesh(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ExternalMesh *result = 0 ;
  
  if (!SWIG_check_num_args("new_ExternalMesh",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ExternalMesh *)new iDynTree::ExternalMesh();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ExternalMesh, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ModelSolidShapes__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ModelSolidShapes *result = 0 ;
  
  if (!SWIG_check_num_args("new_ModelSolidShapes",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ModelSolidShapes *)new iDynTree::ModelSolidShapes();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ModelSolidShapes, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ModelSolidShapes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelSolidShapes *arg1 = (iDynTree::ModelSolidShapes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ModelSolidShapes",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelSolidShapes, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModelSolidShapes" "', argument " "1"" of type '" "iDynTree::ModelSolidShapes *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelSolidShapes * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ModelSolidShapes__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelSolidShapes *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ModelSolidShapes *result = 0 ;
  
  if (!SWIG_check_num_args("new_ModelSolidShapes",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__ModelSolidShapes,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ModelSolidShapes" "', argument " "1"" of type '" "iDynTree::ModelSolidShapes const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ModelSolidShapes" "', argument " "1"" of type '" "iDynTree::ModelSolidShapes const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelSolidShapes * >(argp1);
  result = (iDynTree::ModelSolidShapes *)new iDynTree::ModelSolidShapes((iDynTree::ModelSolidShapes const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ModelSolidShapes, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ModelSolidShapes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_ModelSolidShapes__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelSolidShapes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ModelSolidShapes__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_ModelSolidShapes'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelSolidShapes::ModelSolidShapes()\n"
    "    iDynTree::ModelSolidShapes::ModelSolidShapes(iDynTree::ModelSolidShapes const &)\n");
  return 1;
}


int _wrap_ModelSolidShapes_clear(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelSolidShapes *arg1 = (iDynTree::ModelSolidShapes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ModelSolidShapes_clear",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelSolidShapes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelSolidShapes_clear" "', argument " "1"" of type '" "iDynTree::ModelSolidShapes *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelSolidShapes * >(argp1);
  (arg1)->clear();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelSolidShapes_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelSolidShapes *arg1 = (iDynTree::ModelSolidShapes *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ModelSolidShapes_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelSolidShapes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelSolidShapes_resize" "', argument " "1"" of type '" "iDynTree::ModelSolidShapes *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelSolidShapes * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ModelSolidShapes_resize" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelSolidShapes_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelSolidShapes *arg1 = (iDynTree::ModelSolidShapes *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ModelSolidShapes_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelSolidShapes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelSolidShapes_resize" "', argument " "1"" of type '" "iDynTree::ModelSolidShapes *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelSolidShapes * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelSolidShapes_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelSolidShapes_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelSolidShapes_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelSolidShapes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ModelSolidShapes_resize__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelSolidShapes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ModelSolidShapes_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ModelSolidShapes_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelSolidShapes::resize(size_t)\n"
    "    iDynTree::ModelSolidShapes::resize(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_ModelSolidShapes_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelSolidShapes *arg1 = (iDynTree::ModelSolidShapes *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelSolidShapes_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelSolidShapes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelSolidShapes_isConsistent" "', argument " "1"" of type '" "iDynTree::ModelSolidShapes const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelSolidShapes * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelSolidShapes_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelSolidShapes_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::ModelSolidShapes const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelSolidShapes_getLinkSolidShapes__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelSolidShapes *arg1 = (iDynTree::ModelSolidShapes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > > *result = 0 ;
  
  if (!SWIG_check_num_args("ModelSolidShapes_getLinkSolidShapes",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelSolidShapes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelSolidShapes_getLinkSolidShapes" "', argument " "1"" of type '" "iDynTree::ModelSolidShapes *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelSolidShapes * >(argp1);
  result = (std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > > *) &(arg1)->getLinkSolidShapes();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelSolidShapes_getLinkSolidShapes__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelSolidShapes *arg1 = (iDynTree::ModelSolidShapes *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > > *result = 0 ;
  
  if (!SWIG_check_num_args("ModelSolidShapes_getLinkSolidShapes",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelSolidShapes, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelSolidShapes_getLinkSolidShapes" "', argument " "1"" of type '" "iDynTree::ModelSolidShapes const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelSolidShapes * >(argp1);
  result = (std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > > *) &((iDynTree::ModelSolidShapes const *)arg1)->getLinkSolidShapes();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelSolidShapes_getLinkSolidShapes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelSolidShapes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ModelSolidShapes_getLinkSolidShapes__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelSolidShapes, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ModelSolidShapes_getLinkSolidShapes__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ModelSolidShapes_getLinkSolidShapes'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelSolidShapes::getLinkSolidShapes()\n"
    "    iDynTree::ModelSolidShapes::getLinkSolidShapes() const\n");
  return 1;
}


int _wrap_Neighbor_neighborLink_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Neighbor *arg1 = (iDynTree::Neighbor *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Neighbor_neighborLink_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Neighbor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Neighbor_neighborLink_set" "', argument " "1"" of type '" "iDynTree::Neighbor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Neighbor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Neighbor_neighborLink_set" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  if (arg1) (arg1)->neighborLink = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Neighbor_neighborLink_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Neighbor *arg1 = (iDynTree::Neighbor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("Neighbor_neighborLink_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Neighbor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Neighbor_neighborLink_get" "', argument " "1"" of type '" "iDynTree::Neighbor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Neighbor * >(argp1);
  result =  ((arg1)->neighborLink);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Neighbor_neighborJoint_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Neighbor *arg1 = (iDynTree::Neighbor *) 0 ;
  iDynTree::JointIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Neighbor_neighborJoint_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Neighbor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Neighbor_neighborJoint_set" "', argument " "1"" of type '" "iDynTree::Neighbor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Neighbor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Neighbor_neighborJoint_set" "', argument " "2"" of type '" "iDynTree::JointIndex""'");
  } 
  arg2 = static_cast< iDynTree::JointIndex >(val2);
  if (arg1) (arg1)->neighborJoint = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Neighbor_neighborJoint_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Neighbor *arg1 = (iDynTree::Neighbor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("Neighbor_neighborJoint_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Neighbor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Neighbor_neighborJoint_get" "', argument " "1"" of type '" "iDynTree::Neighbor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Neighbor * >(argp1);
  result =  ((arg1)->neighborJoint);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Neighbor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Neighbor *result = 0 ;
  
  if (!SWIG_check_num_args("new_Neighbor",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Neighbor *)new iDynTree::Neighbor();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Neighbor, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Neighbor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Neighbor *arg1 = (iDynTree::Neighbor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Neighbor",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Neighbor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Neighbor" "', argument " "1"" of type '" "iDynTree::Neighbor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Neighbor * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Model__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Model *result = 0 ;
  
  if (!SWIG_check_num_args("new_Model",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Model *)new iDynTree::Model();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Model, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Model__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Model *result = 0 ;
  
  if (!SWIG_check_num_args("new_Model",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Model" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Model" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::Model *)new iDynTree::Model((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Model, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Model(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Model__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Model__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Model'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Model::Model()\n"
    "    iDynTree::Model::Model(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_Model_copy(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Model result;
  
  if (!SWIG_check_num_args("Model_copy",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_copy" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = ((iDynTree::Model const *)arg1)->copy();
  _out = SWIG_NewPointerObj((new iDynTree::Model(static_cast< const iDynTree::Model& >(result))), SWIGTYPE_p_iDynTree__Model, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Model(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Model",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Model" "', argument " "1"" of type '" "iDynTree::Model *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getNrOfLinks(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("Model_getNrOfLinks",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNrOfLinks" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = ((iDynTree::Model const *)arg1)->getNrOfLinks();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getLinkName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Model_getLinkName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getLinkName" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getLinkName" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = ((iDynTree::Model const *)arg1)->getLinkName(arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("Model_getLinkIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getLinkIndex" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getLinkIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getLinkIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((iDynTree::Model const *)arg1)->getLinkIndex((std::string const &)*arg2);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_Model_isValidLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Model_isValidLinkIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isValidLinkIndex" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_isValidLinkIndex" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (bool)((iDynTree::Model const *)arg1)->isValidLinkIndex(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getLink__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::LinkPtr result;
  
  if (!SWIG_check_num_args("Model_getLink",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getLink" "', argument " "1"" of type '" "iDynTree::Model *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getLink" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::LinkPtr)(arg1)->getLink(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getLink__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::LinkConstPtr result;
  
  if (!SWIG_check_num_args("Model_getLink",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getLink" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getLink" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (iDynTree::LinkConstPtr)((iDynTree::Model const *)arg1)->getLink(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Link, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getLink__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getLink__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Model_getLink'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Model::getLink(iDynTree::LinkIndex const)\n"
    "    iDynTree::Model::getLink(iDynTree::LinkIndex const) const\n");
  return 1;
}


int _wrap_Model_addLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Link *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("Model_addLink",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addLink" "', argument " "1"" of type '" "iDynTree::Model *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_addLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Link,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Model_addLink" "', argument " "3"" of type '" "iDynTree::Link const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_addLink" "', argument " "3"" of type '" "iDynTree::Link const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Link * >(argp3);
  result = (arg1)->addLink((std::string const &)*arg2,(iDynTree::Link const &)*arg3);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_Model_getNrOfJoints(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("Model_getNrOfJoints",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNrOfJoints" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = ((iDynTree::Model const *)arg1)->getNrOfJoints();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getJointName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::JointIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Model_getJointName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getJointName" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getJointName" "', argument " "2"" of type '" "iDynTree::JointIndex""'");
  } 
  arg2 = static_cast< iDynTree::JointIndex >(val2);
  result = ((iDynTree::Model const *)arg1)->getJointName(arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getTotalMass(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("Model_getTotalMass",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getTotalMass" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (double)((iDynTree::Model const *)arg1)->getTotalMass();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getJointIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("Model_getJointIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getJointIndex" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getJointIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getJointIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((iDynTree::Model const *)arg1)->getJointIndex((std::string const &)*arg2);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_Model_getJoint__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::JointIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::IJointPtr result;
  
  if (!SWIG_check_num_args("Model_getJoint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getJoint" "', argument " "1"" of type '" "iDynTree::Model *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getJoint" "', argument " "2"" of type '" "iDynTree::JointIndex""'");
  } 
  arg2 = static_cast< iDynTree::JointIndex >(val2);
  result = (iDynTree::IJointPtr)(arg1)->getJoint(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getJoint__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::JointIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::IJointConstPtr result;
  
  if (!SWIG_check_num_args("Model_getJoint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getJoint" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getJoint" "', argument " "2"" of type '" "iDynTree::JointIndex""'");
  } 
  arg2 = static_cast< iDynTree::JointIndex >(val2);
  result = (iDynTree::IJointConstPtr)((iDynTree::Model const *)arg1)->getJoint(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getJoint__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Model_getJoint__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Model_getJoint'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Model::getJoint(iDynTree::JointIndex const)\n"
    "    iDynTree::Model::getJoint(iDynTree::JointIndex const) const\n");
  return 1;
}


int _wrap_Model_isValidJointIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::JointIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Model_isValidJointIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isValidJointIndex" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_isValidJointIndex" "', argument " "2"" of type '" "iDynTree::JointIndex""'");
  } 
  arg2 = static_cast< iDynTree::JointIndex >(val2);
  result = (bool)((iDynTree::Model const *)arg1)->isValidJointIndex(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_isLinkNameUsed(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Model_isLinkNameUsed",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isLinkNameUsed" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Model_isLinkNameUsed" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)((iDynTree::Model const *)arg1)->isLinkNameUsed(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_isJointNameUsed(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Model_isJointNameUsed",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isJointNameUsed" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Model_isJointNameUsed" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)((iDynTree::Model const *)arg1)->isJointNameUsed(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_isFrameNameUsed(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Model_isFrameNameUsed",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isFrameNameUsed" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Model_isFrameNameUsed" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)((iDynTree::Model const *)arg1)->isFrameNameUsed(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_addJoint__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::IJointConstPtr arg3 = (iDynTree::IJointConstPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("Model_addJoint",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addJoint" "', argument " "1"" of type '" "iDynTree::Model *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addJoint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_addJoint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Model_addJoint" "', argument " "3"" of type '" "iDynTree::IJointConstPtr""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::IJointConstPtr >(argp3);
  result = (arg1)->addJoint((std::string const &)*arg2,arg3);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_Model_addJoint__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  iDynTree::IJointConstPtr arg5 = (iDynTree::IJointConstPtr) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("Model_addJoint",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addJoint" "', argument " "1"" of type '" "iDynTree::Model *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addJoint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_addJoint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Model_addJoint" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_addJoint" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Model_addJoint" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_addJoint" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Model_addJoint" "', argument " "5"" of type '" "iDynTree::IJointConstPtr""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::IJointConstPtr >(argp5);
  result = (arg1)->addJoint((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,arg5);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return 1;
}


int _wrap_Model_addJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__IJoint, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Model_addJoint__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__IJoint, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Model_addJoint__SWIG_1(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Model_addJoint'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Model::addJoint(std::string const &,iDynTree::IJointConstPtr)\n"
    "    iDynTree::Model::addJoint(std::string const &,std::string const &,std::string const &,iDynTree::IJointConstPtr)\n");
  return 1;
}


int _wrap_Model_addJointAndLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  iDynTree::IJointConstPtr arg4 = (iDynTree::IJointConstPtr) 0 ;
  std::string *arg5 = 0 ;
  iDynTree::Link *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("Model_addJointAndLink",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addJointAndLink" "', argument " "1"" of type '" "iDynTree::Model *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addJointAndLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_addJointAndLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Model_addJointAndLink" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_addJointAndLink" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Model_addJointAndLink" "', argument " "4"" of type '" "iDynTree::IJointConstPtr""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::IJointConstPtr >(argp4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Model_addJointAndLink" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_addJointAndLink" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__Link,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Model_addJointAndLink" "', argument " "6"" of type '" "iDynTree::Link &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_addJointAndLink" "', argument " "6"" of type '" "iDynTree::Link &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::Link * >(argp6);
  result = (arg1)->addJointAndLink((std::string const &)*arg2,(std::string const &)*arg3,arg4,(std::string const &)*arg5,*arg6);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return 1;
}


int _wrap_Model_insertLinkToExistingJointAndAddJointForDisplacedLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  iDynTree::Transform *arg4 = 0 ;
  std::string *arg5 = 0 ;
  iDynTree::IJointConstPtr arg6 = (iDynTree::IJointConstPtr) 0 ;
  std::string *arg7 = 0 ;
  iDynTree::Link *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("Model_insertLinkToExistingJointAndAddJointForDisplacedLink",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_insertLinkToExistingJointAndAddJointForDisplacedLink" "', argument " "1"" of type '" "iDynTree::Model *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_insertLinkToExistingJointAndAddJointForDisplacedLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_insertLinkToExistingJointAndAddJointForDisplacedLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Model_insertLinkToExistingJointAndAddJointForDisplacedLink" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_insertLinkToExistingJointAndAddJointForDisplacedLink" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Model_insertLinkToExistingJointAndAddJointForDisplacedLink" "', argument " "4"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_insertLinkToExistingJointAndAddJointForDisplacedLink" "', argument " "4"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Transform * >(argp4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Model_insertLinkToExistingJointAndAddJointForDisplacedLink" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_insertLinkToExistingJointAndAddJointForDisplacedLink" "', argument " "5"" of type '" "std::string const &""'"); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_iDynTree__IJoint, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Model_insertLinkToExistingJointAndAddJointForDisplacedLink" "', argument " "6"" of type '" "iDynTree::IJointConstPtr""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::IJointConstPtr >(argp6);
  {
    std::string *ptr = (std::string *)0;
    res7 = SWIG_AsPtr_std_string(argv[6], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Model_insertLinkToExistingJointAndAddJointForDisplacedLink" "', argument " "7"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_insertLinkToExistingJointAndAddJointForDisplacedLink" "', argument " "7"" of type '" "std::string const &""'"); 
    }
    arg7 = ptr;
  }
  res8 = SWIG_ConvertPtr(argv[7], &argp8, SWIGTYPE_p_iDynTree__Link,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Model_insertLinkToExistingJointAndAddJointForDisplacedLink" "', argument " "8"" of type '" "iDynTree::Link &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_insertLinkToExistingJointAndAddJointForDisplacedLink" "', argument " "8"" of type '" "iDynTree::Link &""'"); 
  }
  arg8 = reinterpret_cast< iDynTree::Link * >(argp8);
  result = (arg1)->insertLinkToExistingJointAndAddJointForDisplacedLink((std::string const &)*arg2,(std::string const &)*arg3,(iDynTree::Transform const &)*arg4,(std::string const &)*arg5,arg6,(std::string const &)*arg7,*arg8);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return 1;
}


int _wrap_Model_getNrOfPosCoords(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("Model_getNrOfPosCoords",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNrOfPosCoords" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = ((iDynTree::Model const *)arg1)->getNrOfPosCoords();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getNrOfDOFs(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("Model_getNrOfDOFs",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNrOfDOFs" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = ((iDynTree::Model const *)arg1)->getNrOfDOFs();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getNrOfFrames(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("Model_getNrOfFrames",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNrOfFrames" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = ((iDynTree::Model const *)arg1)->getNrOfFrames();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_addAdditionalFrameToLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  iDynTree::Transform arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Model_addAdditionalFrameToLink",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_addAdditionalFrameToLink" "', argument " "1"" of type '" "iDynTree::Model *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_addAdditionalFrameToLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_addAdditionalFrameToLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Model_addAdditionalFrameToLink" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_addAdditionalFrameToLink" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Transform,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Model_addAdditionalFrameToLink" "', argument " "4"" of type '" "iDynTree::Transform""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_addAdditionalFrameToLink" "', argument " "4"" of type '" "iDynTree::Transform""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::Transform * >(argp4));
    }
  }
  result = (bool)(arg1)->addAdditionalFrameToLink((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_Model_getFrameName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::FrameIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Model_getFrameName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getFrameName" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getFrameName" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  result = ((iDynTree::Model const *)arg1)->getFrameName(arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getFrameIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  iDynTree::FrameIndex result;
  
  if (!SWIG_check_num_args("Model_getFrameIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getFrameIndex" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getFrameIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getFrameIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = ((iDynTree::Model const *)arg1)->getFrameIndex((std::string const &)*arg2);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_Model_isValidFrameIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::FrameIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Model_isValidFrameIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_isValidFrameIndex" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_isValidFrameIndex" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  result = (bool)((iDynTree::Model const *)arg1)->isValidFrameIndex(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getFrameTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::FrameIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("Model_getFrameTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getFrameTransform" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getFrameTransform" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  result = ((iDynTree::Model const *)arg1)->getFrameTransform(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getFrameLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::FrameIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("Model_getFrameLink",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getFrameLink" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getFrameLink" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  result = ((iDynTree::Model const *)arg1)->getFrameLink(arg2);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getLinkAdditionalFrames(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::LinkIndex arg2 ;
  std::vector< iDynTree::FrameIndex,std::allocator< iDynTree::FrameIndex > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Model_getLinkAdditionalFrames",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getLinkAdditionalFrames" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getLinkAdditionalFrames" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_std__vectorT_std__ptrdiff_t_std__allocatorT_std__ptrdiff_t_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Model_getLinkAdditionalFrames" "', argument " "3"" of type '" "std::vector< iDynTree::FrameIndex,std::allocator< iDynTree::FrameIndex > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getLinkAdditionalFrames" "', argument " "3"" of type '" "std::vector< iDynTree::FrameIndex,std::allocator< iDynTree::FrameIndex > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< iDynTree::FrameIndex,std::allocator< iDynTree::FrameIndex > > * >(argp3);
  result = (bool)((iDynTree::Model const *)arg1)->getLinkAdditionalFrames(arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getNrOfNeighbors(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("Model_getNrOfNeighbors",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNrOfNeighbors" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getNrOfNeighbors" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (unsigned int)((iDynTree::Model const *)arg1)->getNrOfNeighbors(arg2);
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getNeighbor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::LinkIndex arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::Neighbor result;
  
  if (!SWIG_check_num_args("Model_getNeighbor",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getNeighbor" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_getNeighbor" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Model_getNeighbor" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = ((iDynTree::Model const *)arg1)->getNeighbor(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Neighbor(static_cast< const iDynTree::Neighbor& >(result))), SWIGTYPE_p_iDynTree__Neighbor, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_setDefaultBaseLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Model_setDefaultBaseLink",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_setDefaultBaseLink" "', argument " "1"" of type '" "iDynTree::Model *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Model_setDefaultBaseLink" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (bool)(arg1)->setDefaultBaseLink(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_getDefaultBaseLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("Model_getDefaultBaseLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getDefaultBaseLink" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = ((iDynTree::Model const *)arg1)->getDefaultBaseLink();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_computeFullTreeTraversal__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Model_computeFullTreeTraversal",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_computeFullTreeTraversal" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_computeFullTreeTraversal" "', argument " "2"" of type '" "iDynTree::Traversal &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_computeFullTreeTraversal" "', argument " "2"" of type '" "iDynTree::Traversal &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  result = (bool)((iDynTree::Model const *)arg1)->computeFullTreeTraversal(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_computeFullTreeTraversal__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Model_computeFullTreeTraversal",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_computeFullTreeTraversal" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_computeFullTreeTraversal" "', argument " "2"" of type '" "iDynTree::Traversal &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_computeFullTreeTraversal" "', argument " "2"" of type '" "iDynTree::Traversal &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Model_computeFullTreeTraversal" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  result = (bool)((iDynTree::Model const *)arg1)->computeFullTreeTraversal(*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_computeFullTreeTraversal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Traversal, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Model_computeFullTreeTraversal__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Traversal, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Model_computeFullTreeTraversal__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Model_computeFullTreeTraversal'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Model::computeFullTreeTraversal(iDynTree::Traversal &) const\n"
    "    iDynTree::Model::computeFullTreeTraversal(iDynTree::Traversal &,iDynTree::LinkIndex const) const\n");
  return 1;
}


int _wrap_Model_getInertialParameters(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Model_getInertialParameters",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_getInertialParameters" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_getInertialParameters" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_getInertialParameters" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  result = (bool)((iDynTree::Model const *)arg1)->getInertialParameters(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_updateInertialParameters(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Model_updateInertialParameters",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_updateInertialParameters" "', argument " "1"" of type '" "iDynTree::Model *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Model_updateInertialParameters" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Model_updateInertialParameters" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  result = (bool)(arg1)->updateInertialParameters((iDynTree::VectorDynSize const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_visualSolidShapes__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ModelSolidShapes *result = 0 ;
  
  if (!SWIG_check_num_args("Model_visualSolidShapes",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_visualSolidShapes" "', argument " "1"" of type '" "iDynTree::Model *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::ModelSolidShapes *) &(arg1)->visualSolidShapes();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ModelSolidShapes, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_visualSolidShapes__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ModelSolidShapes *result = 0 ;
  
  if (!SWIG_check_num_args("Model_visualSolidShapes",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_visualSolidShapes" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::ModelSolidShapes *) &((iDynTree::Model const *)arg1)->visualSolidShapes();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ModelSolidShapes, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_visualSolidShapes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_visualSolidShapes__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_visualSolidShapes__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Model_visualSolidShapes'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Model::visualSolidShapes()\n"
    "    iDynTree::Model::visualSolidShapes() const\n");
  return 1;
}


int _wrap_Model_collisionSolidShapes__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ModelSolidShapes *result = 0 ;
  
  if (!SWIG_check_num_args("Model_collisionSolidShapes",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_collisionSolidShapes" "', argument " "1"" of type '" "iDynTree::Model *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::ModelSolidShapes *) &(arg1)->collisionSolidShapes();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ModelSolidShapes, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_collisionSolidShapes__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ModelSolidShapes *result = 0 ;
  
  if (!SWIG_check_num_args("Model_collisionSolidShapes",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_collisionSolidShapes" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::ModelSolidShapes *) &((iDynTree::Model const *)arg1)->collisionSolidShapes();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ModelSolidShapes, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Model_collisionSolidShapes(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_collisionSolidShapes__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Model_collisionSolidShapes__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Model_collisionSolidShapes'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Model::collisionSolidShapes()\n"
    "    iDynTree::Model::collisionSolidShapes() const\n");
  return 1;
}


int _wrap_Model_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = (iDynTree::Model *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Model_toString",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Model_toString" "', argument " "1"" of type '" "iDynTree::Model const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = ((iDynTree::Model const *)arg1)->toString();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_JointPosDoubleArray__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::JointPosDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_JointPosDoubleArray",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JointPosDoubleArray" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  result = (iDynTree::JointPosDoubleArray *)new iDynTree::JointPosDoubleArray(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointPosDoubleArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_JointPosDoubleArray__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::JointPosDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_JointPosDoubleArray",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::JointPosDoubleArray *)new iDynTree::JointPosDoubleArray();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointPosDoubleArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_JointPosDoubleArray__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointPosDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_JointPosDoubleArray",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JointPosDoubleArray" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointPosDoubleArray" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::JointPosDoubleArray *)new iDynTree::JointPosDoubleArray((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointPosDoubleArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_JointPosDoubleArray(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_JointPosDoubleArray__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_JointPosDoubleArray__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_JointPosDoubleArray__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_JointPosDoubleArray'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::JointPosDoubleArray::JointPosDoubleArray(std::size_t)\n"
    "    iDynTree::JointPosDoubleArray::JointPosDoubleArray()\n"
    "    iDynTree::JointPosDoubleArray::JointPosDoubleArray(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_JointPosDoubleArray_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::JointPosDoubleArray *arg1 = (iDynTree::JointPosDoubleArray *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("JointPosDoubleArray_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__JointPosDoubleArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JointPosDoubleArray_resize" "', argument " "1"" of type '" "iDynTree::JointPosDoubleArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JointPosDoubleArray_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_JointPosDoubleArray_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::JointPosDoubleArray *arg1 = (iDynTree::JointPosDoubleArray *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("JointPosDoubleArray_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__JointPosDoubleArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JointPosDoubleArray_resize" "', argument " "1"" of type '" "iDynTree::JointPosDoubleArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JointPosDoubleArray_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JointPosDoubleArray_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_JointPosDoubleArray_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__JointPosDoubleArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_JointPosDoubleArray_resize__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__JointPosDoubleArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_JointPosDoubleArray_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'JointPosDoubleArray_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::JointPosDoubleArray::resize(std::size_t)\n"
    "    iDynTree::JointPosDoubleArray::resize(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_JointPosDoubleArray_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::JointPosDoubleArray *arg1 = (iDynTree::JointPosDoubleArray *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("JointPosDoubleArray_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__JointPosDoubleArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JointPosDoubleArray_isConsistent" "', argument " "1"" of type '" "iDynTree::JointPosDoubleArray const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JointPosDoubleArray_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JointPosDoubleArray_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::JointPosDoubleArray const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_JointPosDoubleArray(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::JointPosDoubleArray *arg1 = (iDynTree::JointPosDoubleArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_JointPosDoubleArray",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__JointPosDoubleArray, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JointPosDoubleArray" "', argument " "1"" of type '" "iDynTree::JointPosDoubleArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_JointDOFsDoubleArray__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::JointDOFsDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_JointDOFsDoubleArray",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_JointDOFsDoubleArray" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  result = (iDynTree::JointDOFsDoubleArray *)new iDynTree::JointDOFsDoubleArray(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_JointDOFsDoubleArray__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::JointDOFsDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_JointDOFsDoubleArray",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::JointDOFsDoubleArray *)new iDynTree::JointDOFsDoubleArray();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_JointDOFsDoubleArray__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointDOFsDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_JointDOFsDoubleArray",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_JointDOFsDoubleArray" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_JointDOFsDoubleArray" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::JointDOFsDoubleArray *)new iDynTree::JointDOFsDoubleArray((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_JointDOFsDoubleArray(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_JointDOFsDoubleArray__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_JointDOFsDoubleArray__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_JointDOFsDoubleArray__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_JointDOFsDoubleArray'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::JointDOFsDoubleArray::JointDOFsDoubleArray(std::size_t)\n"
    "    iDynTree::JointDOFsDoubleArray::JointDOFsDoubleArray()\n"
    "    iDynTree::JointDOFsDoubleArray::JointDOFsDoubleArray(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_JointDOFsDoubleArray_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::JointDOFsDoubleArray *arg1 = (iDynTree::JointDOFsDoubleArray *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("JointDOFsDoubleArray_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JointDOFsDoubleArray_resize" "', argument " "1"" of type '" "iDynTree::JointDOFsDoubleArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JointDOFsDoubleArray_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_JointDOFsDoubleArray_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::JointDOFsDoubleArray *arg1 = (iDynTree::JointDOFsDoubleArray *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("JointDOFsDoubleArray_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JointDOFsDoubleArray_resize" "', argument " "1"" of type '" "iDynTree::JointDOFsDoubleArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JointDOFsDoubleArray_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JointDOFsDoubleArray_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_JointDOFsDoubleArray_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_JointDOFsDoubleArray_resize__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_JointDOFsDoubleArray_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'JointDOFsDoubleArray_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::JointDOFsDoubleArray::resize(std::size_t)\n"
    "    iDynTree::JointDOFsDoubleArray::resize(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_JointDOFsDoubleArray_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::JointDOFsDoubleArray *arg1 = (iDynTree::JointDOFsDoubleArray *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("JointDOFsDoubleArray_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JointDOFsDoubleArray_isConsistent" "', argument " "1"" of type '" "iDynTree::JointDOFsDoubleArray const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JointDOFsDoubleArray_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JointDOFsDoubleArray_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::JointDOFsDoubleArray const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_JointDOFsDoubleArray(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::JointDOFsDoubleArray *arg1 = (iDynTree::JointDOFsDoubleArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_JointDOFsDoubleArray",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JointDOFsDoubleArray" "', argument " "1"" of type '" "iDynTree::JointDOFsDoubleArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DOFSpatialForceArray__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::DOFSpatialForceArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_DOFSpatialForceArray",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DOFSpatialForceArray" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  result = (iDynTree::DOFSpatialForceArray *)new iDynTree::DOFSpatialForceArray(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__DOFSpatialForceArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DOFSpatialForceArray__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::DOFSpatialForceArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_DOFSpatialForceArray",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::DOFSpatialForceArray *)new iDynTree::DOFSpatialForceArray();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__DOFSpatialForceArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DOFSpatialForceArray__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::DOFSpatialForceArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_DOFSpatialForceArray",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DOFSpatialForceArray" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DOFSpatialForceArray" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::DOFSpatialForceArray *)new iDynTree::DOFSpatialForceArray((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__DOFSpatialForceArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DOFSpatialForceArray(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_DOFSpatialForceArray__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DOFSpatialForceArray__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DOFSpatialForceArray__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_DOFSpatialForceArray'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::DOFSpatialForceArray::DOFSpatialForceArray(std::size_t)\n"
    "    iDynTree::DOFSpatialForceArray::DOFSpatialForceArray()\n"
    "    iDynTree::DOFSpatialForceArray::DOFSpatialForceArray(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_DOFSpatialForceArray_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DOFSpatialForceArray *arg1 = (iDynTree::DOFSpatialForceArray *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("DOFSpatialForceArray_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DOFSpatialForceArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOFSpatialForceArray_resize" "', argument " "1"" of type '" "iDynTree::DOFSpatialForceArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DOFSpatialForceArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOFSpatialForceArray_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DOFSpatialForceArray_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DOFSpatialForceArray *arg1 = (iDynTree::DOFSpatialForceArray *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("DOFSpatialForceArray_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DOFSpatialForceArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOFSpatialForceArray_resize" "', argument " "1"" of type '" "iDynTree::DOFSpatialForceArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DOFSpatialForceArray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOFSpatialForceArray_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DOFSpatialForceArray_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DOFSpatialForceArray_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__DOFSpatialForceArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DOFSpatialForceArray_resize__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__DOFSpatialForceArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DOFSpatialForceArray_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'DOFSpatialForceArray_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::DOFSpatialForceArray::resize(std::size_t const)\n"
    "    iDynTree::DOFSpatialForceArray::resize(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_DOFSpatialForceArray_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DOFSpatialForceArray *arg1 = (iDynTree::DOFSpatialForceArray *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DOFSpatialForceArray_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DOFSpatialForceArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOFSpatialForceArray_isConsistent" "', argument " "1"" of type '" "iDynTree::DOFSpatialForceArray const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DOFSpatialForceArray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOFSpatialForceArray_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DOFSpatialForceArray_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::DOFSpatialForceArray const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DOFSpatialForceArray_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DOFSpatialForceArray *arg1 = (iDynTree::DOFSpatialForceArray *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector *result = 0 ;
  
  if (!SWIG_check_num_args("DOFSpatialForceArray_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DOFSpatialForceArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOFSpatialForceArray_paren" "', argument " "1"" of type '" "iDynTree::DOFSpatialForceArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DOFSpatialForceArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOFSpatialForceArray_paren" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (iDynTree::SpatialForceVector *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialForceVector, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DOFSpatialForceArray_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DOFSpatialForceArray *arg1 = (iDynTree::DOFSpatialForceArray *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialForceVector *result = 0 ;
  
  if (!SWIG_check_num_args("DOFSpatialForceArray_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DOFSpatialForceArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOFSpatialForceArray_paren" "', argument " "1"" of type '" "iDynTree::DOFSpatialForceArray const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DOFSpatialForceArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOFSpatialForceArray_paren" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (iDynTree::SpatialForceVector *) &((iDynTree::DOFSpatialForceArray const *)arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialForceVector, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DOFSpatialForceArray_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__DOFSpatialForceArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DOFSpatialForceArray_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__DOFSpatialForceArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DOFSpatialForceArray_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'DOFSpatialForceArray_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::DOFSpatialForceArray::operator ()(size_t const)\n"
    "    iDynTree::DOFSpatialForceArray::operator ()(size_t const) const\n");
  return 1;
}


int _wrap_delete_DOFSpatialForceArray(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DOFSpatialForceArray *arg1 = (iDynTree::DOFSpatialForceArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_DOFSpatialForceArray",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DOFSpatialForceArray, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOFSpatialForceArray" "', argument " "1"" of type '" "iDynTree::DOFSpatialForceArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DOFSpatialForceArray * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DOFSpatialMotionArray__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::DOFSpatialMotionArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_DOFSpatialMotionArray",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DOFSpatialMotionArray" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  result = (iDynTree::DOFSpatialMotionArray *)new iDynTree::DOFSpatialMotionArray(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DOFSpatialMotionArray__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::DOFSpatialMotionArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_DOFSpatialMotionArray",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::DOFSpatialMotionArray *)new iDynTree::DOFSpatialMotionArray();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DOFSpatialMotionArray__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::DOFSpatialMotionArray *result = 0 ;
  
  if (!SWIG_check_num_args("new_DOFSpatialMotionArray",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DOFSpatialMotionArray" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DOFSpatialMotionArray" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::DOFSpatialMotionArray *)new iDynTree::DOFSpatialMotionArray((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_DOFSpatialMotionArray(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_DOFSpatialMotionArray__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DOFSpatialMotionArray__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DOFSpatialMotionArray__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_DOFSpatialMotionArray'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::DOFSpatialMotionArray::DOFSpatialMotionArray(std::size_t)\n"
    "    iDynTree::DOFSpatialMotionArray::DOFSpatialMotionArray()\n"
    "    iDynTree::DOFSpatialMotionArray::DOFSpatialMotionArray(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_DOFSpatialMotionArray_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DOFSpatialMotionArray *arg1 = (iDynTree::DOFSpatialMotionArray *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("DOFSpatialMotionArray_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOFSpatialMotionArray_resize" "', argument " "1"" of type '" "iDynTree::DOFSpatialMotionArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DOFSpatialMotionArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOFSpatialMotionArray_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DOFSpatialMotionArray_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DOFSpatialMotionArray *arg1 = (iDynTree::DOFSpatialMotionArray *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("DOFSpatialMotionArray_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOFSpatialMotionArray_resize" "', argument " "1"" of type '" "iDynTree::DOFSpatialMotionArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DOFSpatialMotionArray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOFSpatialMotionArray_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DOFSpatialMotionArray_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DOFSpatialMotionArray_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_DOFSpatialMotionArray_resize__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DOFSpatialMotionArray_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'DOFSpatialMotionArray_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::DOFSpatialMotionArray::resize(std::size_t const)\n"
    "    iDynTree::DOFSpatialMotionArray::resize(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_DOFSpatialMotionArray_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DOFSpatialMotionArray *arg1 = (iDynTree::DOFSpatialMotionArray *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DOFSpatialMotionArray_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOFSpatialMotionArray_isConsistent" "', argument " "1"" of type '" "iDynTree::DOFSpatialMotionArray const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DOFSpatialMotionArray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DOFSpatialMotionArray_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DOFSpatialMotionArray_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::DOFSpatialMotionArray const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DOFSpatialMotionArray_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DOFSpatialMotionArray *arg1 = (iDynTree::DOFSpatialMotionArray *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector *result = 0 ;
  
  if (!SWIG_check_num_args("DOFSpatialMotionArray_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOFSpatialMotionArray_paren" "', argument " "1"" of type '" "iDynTree::DOFSpatialMotionArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DOFSpatialMotionArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOFSpatialMotionArray_paren" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (iDynTree::SpatialMotionVector *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialMotionVector, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DOFSpatialMotionArray_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DOFSpatialMotionArray *arg1 = (iDynTree::DOFSpatialMotionArray *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMotionVector *result = 0 ;
  
  if (!SWIG_check_num_args("DOFSpatialMotionArray_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DOFSpatialMotionArray_paren" "', argument " "1"" of type '" "iDynTree::DOFSpatialMotionArray const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DOFSpatialMotionArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DOFSpatialMotionArray_paren" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (iDynTree::SpatialMotionVector *) &((iDynTree::DOFSpatialMotionArray const *)arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialMotionVector, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DOFSpatialMotionArray_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DOFSpatialMotionArray_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DOFSpatialMotionArray_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'DOFSpatialMotionArray_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::DOFSpatialMotionArray::operator ()(size_t const)\n"
    "    iDynTree::DOFSpatialMotionArray::operator ()(size_t const) const\n");
  return 1;
}


int _wrap_delete_DOFSpatialMotionArray(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DOFSpatialMotionArray *arg1 = (iDynTree::DOFSpatialMotionArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_DOFSpatialMotionArray",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DOFSpatialMotionArray" "', argument " "1"" of type '" "iDynTree::DOFSpatialMotionArray *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DOFSpatialMotionArray * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FrameFreeFloatingJacobian__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::FrameFreeFloatingJacobian *result = 0 ;
  
  if (!SWIG_check_num_args("new_FrameFreeFloatingJacobian",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FrameFreeFloatingJacobian" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  result = (iDynTree::FrameFreeFloatingJacobian *)new iDynTree::FrameFreeFloatingJacobian(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FrameFreeFloatingJacobian, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FrameFreeFloatingJacobian__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::FrameFreeFloatingJacobian *result = 0 ;
  
  if (!SWIG_check_num_args("new_FrameFreeFloatingJacobian",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::FrameFreeFloatingJacobian *)new iDynTree::FrameFreeFloatingJacobian();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FrameFreeFloatingJacobian, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FrameFreeFloatingJacobian__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::FrameFreeFloatingJacobian *result = 0 ;
  
  if (!SWIG_check_num_args("new_FrameFreeFloatingJacobian",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FrameFreeFloatingJacobian" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FrameFreeFloatingJacobian" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::FrameFreeFloatingJacobian *)new iDynTree::FrameFreeFloatingJacobian((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FrameFreeFloatingJacobian, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FrameFreeFloatingJacobian(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_FrameFreeFloatingJacobian__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FrameFreeFloatingJacobian__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_FrameFreeFloatingJacobian__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_FrameFreeFloatingJacobian'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FrameFreeFloatingJacobian::FrameFreeFloatingJacobian(size_t)\n"
    "    iDynTree::FrameFreeFloatingJacobian::FrameFreeFloatingJacobian()\n"
    "    iDynTree::FrameFreeFloatingJacobian::FrameFreeFloatingJacobian(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_FrameFreeFloatingJacobian_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FrameFreeFloatingJacobian *arg1 = (iDynTree::FrameFreeFloatingJacobian *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FrameFreeFloatingJacobian_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FrameFreeFloatingJacobian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameFreeFloatingJacobian_resize" "', argument " "1"" of type '" "iDynTree::FrameFreeFloatingJacobian *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FrameFreeFloatingJacobian * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrameFreeFloatingJacobian_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FrameFreeFloatingJacobian_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FrameFreeFloatingJacobian_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FrameFreeFloatingJacobian *arg1 = (iDynTree::FrameFreeFloatingJacobian *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("FrameFreeFloatingJacobian_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FrameFreeFloatingJacobian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FrameFreeFloatingJacobian_isConsistent" "', argument " "1"" of type '" "iDynTree::FrameFreeFloatingJacobian const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FrameFreeFloatingJacobian * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FrameFreeFloatingJacobian_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FrameFreeFloatingJacobian_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::FrameFreeFloatingJacobian const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_FrameFreeFloatingJacobian(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FrameFreeFloatingJacobian *arg1 = (iDynTree::FrameFreeFloatingJacobian *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_FrameFreeFloatingJacobian",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FrameFreeFloatingJacobian, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FrameFreeFloatingJacobian" "', argument " "1"" of type '" "iDynTree::FrameFreeFloatingJacobian *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FrameFreeFloatingJacobian * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_MomentumFreeFloatingJacobian__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::MomentumFreeFloatingJacobian *result = 0 ;
  
  if (!SWIG_check_num_args("new_MomentumFreeFloatingJacobian",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MomentumFreeFloatingJacobian" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  result = (iDynTree::MomentumFreeFloatingJacobian *)new iDynTree::MomentumFreeFloatingJacobian(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MomentumFreeFloatingJacobian, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_MomentumFreeFloatingJacobian__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::MomentumFreeFloatingJacobian *result = 0 ;
  
  if (!SWIG_check_num_args("new_MomentumFreeFloatingJacobian",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::MomentumFreeFloatingJacobian *)new iDynTree::MomentumFreeFloatingJacobian();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MomentumFreeFloatingJacobian, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_MomentumFreeFloatingJacobian__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MomentumFreeFloatingJacobian *result = 0 ;
  
  if (!SWIG_check_num_args("new_MomentumFreeFloatingJacobian",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MomentumFreeFloatingJacobian" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MomentumFreeFloatingJacobian" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::MomentumFreeFloatingJacobian *)new iDynTree::MomentumFreeFloatingJacobian((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MomentumFreeFloatingJacobian, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_MomentumFreeFloatingJacobian(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_MomentumFreeFloatingJacobian__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MomentumFreeFloatingJacobian__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_MomentumFreeFloatingJacobian__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_MomentumFreeFloatingJacobian'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::MomentumFreeFloatingJacobian::MomentumFreeFloatingJacobian(size_t)\n"
    "    iDynTree::MomentumFreeFloatingJacobian::MomentumFreeFloatingJacobian()\n"
    "    iDynTree::MomentumFreeFloatingJacobian::MomentumFreeFloatingJacobian(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_MomentumFreeFloatingJacobian_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MomentumFreeFloatingJacobian *arg1 = (iDynTree::MomentumFreeFloatingJacobian *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("MomentumFreeFloatingJacobian_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MomentumFreeFloatingJacobian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MomentumFreeFloatingJacobian_resize" "', argument " "1"" of type '" "iDynTree::MomentumFreeFloatingJacobian *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MomentumFreeFloatingJacobian * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MomentumFreeFloatingJacobian_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MomentumFreeFloatingJacobian_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_MomentumFreeFloatingJacobian_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MomentumFreeFloatingJacobian *arg1 = (iDynTree::MomentumFreeFloatingJacobian *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("MomentumFreeFloatingJacobian_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MomentumFreeFloatingJacobian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MomentumFreeFloatingJacobian_isConsistent" "', argument " "1"" of type '" "iDynTree::MomentumFreeFloatingJacobian const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MomentumFreeFloatingJacobian * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MomentumFreeFloatingJacobian_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MomentumFreeFloatingJacobian_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::MomentumFreeFloatingJacobian const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_MomentumFreeFloatingJacobian(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::MomentumFreeFloatingJacobian *arg1 = (iDynTree::MomentumFreeFloatingJacobian *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_MomentumFreeFloatingJacobian",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__MomentumFreeFloatingJacobian, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MomentumFreeFloatingJacobian" "', argument " "1"" of type '" "iDynTree::MomentumFreeFloatingJacobian *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::MomentumFreeFloatingJacobian * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingMassMatrix__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::FreeFloatingMassMatrix *result = 0 ;
  
  if (!SWIG_check_num_args("new_FreeFloatingMassMatrix",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FreeFloatingMassMatrix" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  result = (iDynTree::FreeFloatingMassMatrix *)new iDynTree::FreeFloatingMassMatrix(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FreeFloatingMassMatrix, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingMassMatrix__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::FreeFloatingMassMatrix *result = 0 ;
  
  if (!SWIG_check_num_args("new_FreeFloatingMassMatrix",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::FreeFloatingMassMatrix *)new iDynTree::FreeFloatingMassMatrix();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FreeFloatingMassMatrix, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingMassMatrix__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::FreeFloatingMassMatrix *result = 0 ;
  
  if (!SWIG_check_num_args("new_FreeFloatingMassMatrix",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FreeFloatingMassMatrix" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FreeFloatingMassMatrix" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::FreeFloatingMassMatrix *)new iDynTree::FreeFloatingMassMatrix((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FreeFloatingMassMatrix, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingMassMatrix(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_FreeFloatingMassMatrix__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FreeFloatingMassMatrix__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_FreeFloatingMassMatrix__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_FreeFloatingMassMatrix'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FreeFloatingMassMatrix::FreeFloatingMassMatrix(size_t)\n"
    "    iDynTree::FreeFloatingMassMatrix::FreeFloatingMassMatrix()\n"
    "    iDynTree::FreeFloatingMassMatrix::FreeFloatingMassMatrix(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_FreeFloatingMassMatrix_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingMassMatrix *arg1 = (iDynTree::FreeFloatingMassMatrix *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FreeFloatingMassMatrix_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingMassMatrix, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingMassMatrix_resize" "', argument " "1"" of type '" "iDynTree::FreeFloatingMassMatrix *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingMassMatrix * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FreeFloatingMassMatrix_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FreeFloatingMassMatrix_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_FreeFloatingMassMatrix(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingMassMatrix *arg1 = (iDynTree::FreeFloatingMassMatrix *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_FreeFloatingMassMatrix",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingMassMatrix, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FreeFloatingMassMatrix" "', argument " "1"" of type '" "iDynTree::FreeFloatingMassMatrix *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingMassMatrix * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingPos__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::FreeFloatingPos *result = 0 ;
  
  if (!SWIG_check_num_args("new_FreeFloatingPos",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::FreeFloatingPos *)new iDynTree::FreeFloatingPos();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FreeFloatingPos, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingPos__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::FreeFloatingPos *result = 0 ;
  
  if (!SWIG_check_num_args("new_FreeFloatingPos",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FreeFloatingPos" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FreeFloatingPos" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::FreeFloatingPos *)new iDynTree::FreeFloatingPos((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FreeFloatingPos, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingPos(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_FreeFloatingPos__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FreeFloatingPos__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_FreeFloatingPos'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FreeFloatingPos::FreeFloatingPos()\n"
    "    iDynTree::FreeFloatingPos::FreeFloatingPos(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_FreeFloatingPos_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingPos *arg1 = (iDynTree::FreeFloatingPos *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FreeFloatingPos_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingPos, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingPos_resize" "', argument " "1"" of type '" "iDynTree::FreeFloatingPos *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FreeFloatingPos_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FreeFloatingPos_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingPos_worldBasePos__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingPos *arg1 = (iDynTree::FreeFloatingPos *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingPos_worldBasePos",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingPos, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingPos_worldBasePos" "', argument " "1"" of type '" "iDynTree::FreeFloatingPos *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp1);
  result = (iDynTree::Transform *) &(arg1)->worldBasePos();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingPos_jointPos__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingPos *arg1 = (iDynTree::FreeFloatingPos *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointPosDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingPos_jointPos",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingPos, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingPos_jointPos" "', argument " "1"" of type '" "iDynTree::FreeFloatingPos *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp1);
  result = (iDynTree::JointPosDoubleArray *) &(arg1)->jointPos();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointPosDoubleArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingPos_worldBasePos__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingPos *arg1 = (iDynTree::FreeFloatingPos *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingPos_worldBasePos",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingPos, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingPos_worldBasePos" "', argument " "1"" of type '" "iDynTree::FreeFloatingPos const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp1);
  result = (iDynTree::Transform *) &((iDynTree::FreeFloatingPos const *)arg1)->worldBasePos();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingPos_worldBasePos(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingPos, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingPos_worldBasePos__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingPos, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingPos_worldBasePos__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'FreeFloatingPos_worldBasePos'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FreeFloatingPos::worldBasePos()\n"
    "    iDynTree::FreeFloatingPos::worldBasePos() const\n");
  return 1;
}


int _wrap_FreeFloatingPos_jointPos__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingPos *arg1 = (iDynTree::FreeFloatingPos *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointPosDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingPos_jointPos",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingPos, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingPos_jointPos" "', argument " "1"" of type '" "iDynTree::FreeFloatingPos const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp1);
  result = (iDynTree::JointPosDoubleArray *) &((iDynTree::FreeFloatingPos const *)arg1)->jointPos();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointPosDoubleArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingPos_jointPos(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingPos, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingPos_jointPos__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingPos, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingPos_jointPos__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'FreeFloatingPos_jointPos'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FreeFloatingPos::jointPos()\n"
    "    iDynTree::FreeFloatingPos::jointPos() const\n");
  return 1;
}


int _wrap_FreeFloatingPos_getNrOfPosCoords(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingPos *arg1 = (iDynTree::FreeFloatingPos *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("FreeFloatingPos_getNrOfPosCoords",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingPos, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingPos_getNrOfPosCoords" "', argument " "1"" of type '" "iDynTree::FreeFloatingPos const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp1);
  result = (unsigned int)((iDynTree::FreeFloatingPos const *)arg1)->getNrOfPosCoords();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_FreeFloatingPos(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingPos *arg1 = (iDynTree::FreeFloatingPos *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_FreeFloatingPos",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingPos, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FreeFloatingPos" "', argument " "1"" of type '" "iDynTree::FreeFloatingPos *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingGeneralizedTorques__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::FreeFloatingGeneralizedTorques *result = 0 ;
  
  if (!SWIG_check_num_args("new_FreeFloatingGeneralizedTorques",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::FreeFloatingGeneralizedTorques *)new iDynTree::FreeFloatingGeneralizedTorques();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingGeneralizedTorques__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::FreeFloatingGeneralizedTorques *result = 0 ;
  
  if (!SWIG_check_num_args("new_FreeFloatingGeneralizedTorques",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FreeFloatingGeneralizedTorques" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FreeFloatingGeneralizedTorques" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::FreeFloatingGeneralizedTorques *)new iDynTree::FreeFloatingGeneralizedTorques((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingGeneralizedTorques(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_FreeFloatingGeneralizedTorques__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FreeFloatingGeneralizedTorques__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_FreeFloatingGeneralizedTorques'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FreeFloatingGeneralizedTorques::FreeFloatingGeneralizedTorques()\n"
    "    iDynTree::FreeFloatingGeneralizedTorques::FreeFloatingGeneralizedTorques(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_FreeFloatingGeneralizedTorques_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingGeneralizedTorques *arg1 = (iDynTree::FreeFloatingGeneralizedTorques *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FreeFloatingGeneralizedTorques_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingGeneralizedTorques_resize" "', argument " "1"" of type '" "iDynTree::FreeFloatingGeneralizedTorques *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingGeneralizedTorques * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FreeFloatingGeneralizedTorques_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FreeFloatingGeneralizedTorques_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingGeneralizedTorques_baseWrench__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingGeneralizedTorques *arg1 = (iDynTree::FreeFloatingGeneralizedTorques *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Wrench *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingGeneralizedTorques_baseWrench",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingGeneralizedTorques_baseWrench" "', argument " "1"" of type '" "iDynTree::FreeFloatingGeneralizedTorques *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingGeneralizedTorques * >(argp1);
  result = (iDynTree::Wrench *) &(arg1)->baseWrench();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Wrench, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingGeneralizedTorques_jointTorques__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingGeneralizedTorques *arg1 = (iDynTree::FreeFloatingGeneralizedTorques *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointDOFsDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingGeneralizedTorques_jointTorques",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingGeneralizedTorques_jointTorques" "', argument " "1"" of type '" "iDynTree::FreeFloatingGeneralizedTorques *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingGeneralizedTorques * >(argp1);
  result = (iDynTree::JointDOFsDoubleArray *) &(arg1)->jointTorques();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingGeneralizedTorques_baseWrench__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingGeneralizedTorques *arg1 = (iDynTree::FreeFloatingGeneralizedTorques *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Wrench *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingGeneralizedTorques_baseWrench",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingGeneralizedTorques_baseWrench" "', argument " "1"" of type '" "iDynTree::FreeFloatingGeneralizedTorques const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingGeneralizedTorques * >(argp1);
  result = (iDynTree::Wrench *) &((iDynTree::FreeFloatingGeneralizedTorques const *)arg1)->baseWrench();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Wrench, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingGeneralizedTorques_baseWrench(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingGeneralizedTorques_baseWrench__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingGeneralizedTorques_baseWrench__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'FreeFloatingGeneralizedTorques_baseWrench'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FreeFloatingGeneralizedTorques::baseWrench()\n"
    "    iDynTree::FreeFloatingGeneralizedTorques::baseWrench() const\n");
  return 1;
}


int _wrap_FreeFloatingGeneralizedTorques_jointTorques__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingGeneralizedTorques *arg1 = (iDynTree::FreeFloatingGeneralizedTorques *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointDOFsDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingGeneralizedTorques_jointTorques",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingGeneralizedTorques_jointTorques" "', argument " "1"" of type '" "iDynTree::FreeFloatingGeneralizedTorques const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingGeneralizedTorques * >(argp1);
  result = (iDynTree::JointDOFsDoubleArray *) &((iDynTree::FreeFloatingGeneralizedTorques const *)arg1)->jointTorques();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingGeneralizedTorques_jointTorques(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingGeneralizedTorques_jointTorques__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingGeneralizedTorques_jointTorques__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'FreeFloatingGeneralizedTorques_jointTorques'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FreeFloatingGeneralizedTorques::jointTorques()\n"
    "    iDynTree::FreeFloatingGeneralizedTorques::jointTorques() const\n");
  return 1;
}


int _wrap_FreeFloatingGeneralizedTorques_getNrOfDOFs(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingGeneralizedTorques *arg1 = (iDynTree::FreeFloatingGeneralizedTorques *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("FreeFloatingGeneralizedTorques_getNrOfDOFs",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingGeneralizedTorques_getNrOfDOFs" "', argument " "1"" of type '" "iDynTree::FreeFloatingGeneralizedTorques const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingGeneralizedTorques * >(argp1);
  result = (unsigned int)((iDynTree::FreeFloatingGeneralizedTorques const *)arg1)->getNrOfDOFs();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_FreeFloatingGeneralizedTorques(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingGeneralizedTorques *arg1 = (iDynTree::FreeFloatingGeneralizedTorques *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_FreeFloatingGeneralizedTorques",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FreeFloatingGeneralizedTorques" "', argument " "1"" of type '" "iDynTree::FreeFloatingGeneralizedTorques *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingGeneralizedTorques * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingVel__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::FreeFloatingVel *result = 0 ;
  
  if (!SWIG_check_num_args("new_FreeFloatingVel",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::FreeFloatingVel *)new iDynTree::FreeFloatingVel();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FreeFloatingVel, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingVel__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::FreeFloatingVel *result = 0 ;
  
  if (!SWIG_check_num_args("new_FreeFloatingVel",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FreeFloatingVel" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FreeFloatingVel" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::FreeFloatingVel *)new iDynTree::FreeFloatingVel((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FreeFloatingVel, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingVel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_FreeFloatingVel__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FreeFloatingVel__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_FreeFloatingVel'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FreeFloatingVel::FreeFloatingVel()\n"
    "    iDynTree::FreeFloatingVel::FreeFloatingVel(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_FreeFloatingVel_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingVel *arg1 = (iDynTree::FreeFloatingVel *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FreeFloatingVel_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingVel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingVel_resize" "', argument " "1"" of type '" "iDynTree::FreeFloatingVel *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FreeFloatingVel_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FreeFloatingVel_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingVel_baseVel__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingVel *arg1 = (iDynTree::FreeFloatingVel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Twist *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingVel_baseVel",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingVel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingVel_baseVel" "', argument " "1"" of type '" "iDynTree::FreeFloatingVel *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp1);
  result = (iDynTree::Twist *) &(arg1)->baseVel();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Twist, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingVel_jointVel__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingVel *arg1 = (iDynTree::FreeFloatingVel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointDOFsDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingVel_jointVel",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingVel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingVel_jointVel" "', argument " "1"" of type '" "iDynTree::FreeFloatingVel *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp1);
  result = (iDynTree::JointDOFsDoubleArray *) &(arg1)->jointVel();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingVel_baseVel__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingVel *arg1 = (iDynTree::FreeFloatingVel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Twist *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingVel_baseVel",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingVel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingVel_baseVel" "', argument " "1"" of type '" "iDynTree::FreeFloatingVel const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp1);
  result = (iDynTree::Twist *) &((iDynTree::FreeFloatingVel const *)arg1)->baseVel();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Twist, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingVel_baseVel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingVel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingVel_baseVel__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingVel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingVel_baseVel__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'FreeFloatingVel_baseVel'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FreeFloatingVel::baseVel()\n"
    "    iDynTree::FreeFloatingVel::baseVel() const\n");
  return 1;
}


int _wrap_FreeFloatingVel_jointVel__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingVel *arg1 = (iDynTree::FreeFloatingVel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointDOFsDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingVel_jointVel",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingVel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingVel_jointVel" "', argument " "1"" of type '" "iDynTree::FreeFloatingVel const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp1);
  result = (iDynTree::JointDOFsDoubleArray *) &((iDynTree::FreeFloatingVel const *)arg1)->jointVel();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingVel_jointVel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingVel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingVel_jointVel__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingVel, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingVel_jointVel__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'FreeFloatingVel_jointVel'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FreeFloatingVel::jointVel()\n"
    "    iDynTree::FreeFloatingVel::jointVel() const\n");
  return 1;
}


int _wrap_FreeFloatingVel_getNrOfDOFs(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingVel *arg1 = (iDynTree::FreeFloatingVel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("FreeFloatingVel_getNrOfDOFs",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingVel, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingVel_getNrOfDOFs" "', argument " "1"" of type '" "iDynTree::FreeFloatingVel const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp1);
  result = (unsigned int)((iDynTree::FreeFloatingVel const *)arg1)->getNrOfDOFs();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_FreeFloatingVel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingVel *arg1 = (iDynTree::FreeFloatingVel *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_FreeFloatingVel",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingVel, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FreeFloatingVel" "', argument " "1"" of type '" "iDynTree::FreeFloatingVel *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingAcc__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::FreeFloatingAcc *result = 0 ;
  
  if (!SWIG_check_num_args("new_FreeFloatingAcc",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::FreeFloatingAcc *)new iDynTree::FreeFloatingAcc();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FreeFloatingAcc, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingAcc__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::FreeFloatingAcc *result = 0 ;
  
  if (!SWIG_check_num_args("new_FreeFloatingAcc",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FreeFloatingAcc" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FreeFloatingAcc" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::FreeFloatingAcc *)new iDynTree::FreeFloatingAcc((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__FreeFloatingAcc, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_FreeFloatingAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_FreeFloatingAcc__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FreeFloatingAcc__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_FreeFloatingAcc'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FreeFloatingAcc::FreeFloatingAcc()\n"
    "    iDynTree::FreeFloatingAcc::FreeFloatingAcc(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_FreeFloatingAcc_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingAcc *arg1 = (iDynTree::FreeFloatingAcc *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("FreeFloatingAcc_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingAcc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingAcc_resize" "', argument " "1"" of type '" "iDynTree::FreeFloatingAcc *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingAcc * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FreeFloatingAcc_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FreeFloatingAcc_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingAcc_baseAcc__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingAcc *arg1 = (iDynTree::FreeFloatingAcc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingAcc_baseAcc",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingAcc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingAcc_baseAcc" "', argument " "1"" of type '" "iDynTree::FreeFloatingAcc *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingAcc * >(argp1);
  result = (iDynTree::SpatialAcc *) &(arg1)->baseAcc();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialAcc, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingAcc_jointAcc__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingAcc *arg1 = (iDynTree::FreeFloatingAcc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointDOFsDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingAcc_jointAcc",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingAcc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingAcc_jointAcc" "', argument " "1"" of type '" "iDynTree::FreeFloatingAcc *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingAcc * >(argp1);
  result = (iDynTree::JointDOFsDoubleArray *) &(arg1)->jointAcc();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingAcc_baseAcc__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingAcc *arg1 = (iDynTree::FreeFloatingAcc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialAcc *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingAcc_baseAcc",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingAcc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingAcc_baseAcc" "', argument " "1"" of type '" "iDynTree::FreeFloatingAcc const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingAcc * >(argp1);
  result = (iDynTree::SpatialAcc *) &((iDynTree::FreeFloatingAcc const *)arg1)->baseAcc();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SpatialAcc, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingAcc_baseAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingAcc, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingAcc_baseAcc__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingAcc, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingAcc_baseAcc__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'FreeFloatingAcc_baseAcc'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FreeFloatingAcc::baseAcc()\n"
    "    iDynTree::FreeFloatingAcc::baseAcc() const\n");
  return 1;
}


int _wrap_FreeFloatingAcc_jointAcc__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingAcc *arg1 = (iDynTree::FreeFloatingAcc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointDOFsDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("FreeFloatingAcc_jointAcc",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingAcc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingAcc_jointAcc" "', argument " "1"" of type '" "iDynTree::FreeFloatingAcc const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingAcc * >(argp1);
  result = (iDynTree::JointDOFsDoubleArray *) &((iDynTree::FreeFloatingAcc const *)arg1)->jointAcc();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_FreeFloatingAcc_jointAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingAcc, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingAcc_jointAcc__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingAcc, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FreeFloatingAcc_jointAcc__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'FreeFloatingAcc_jointAcc'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::FreeFloatingAcc::jointAcc()\n"
    "    iDynTree::FreeFloatingAcc::jointAcc() const\n");
  return 1;
}


int _wrap_FreeFloatingAcc_getNrOfDOFs(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingAcc *arg1 = (iDynTree::FreeFloatingAcc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("FreeFloatingAcc_getNrOfDOFs",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingAcc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FreeFloatingAcc_getNrOfDOFs" "', argument " "1"" of type '" "iDynTree::FreeFloatingAcc const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingAcc * >(argp1);
  result = (unsigned int)((iDynTree::FreeFloatingAcc const *)arg1)->getNrOfDOFs();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_FreeFloatingAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::FreeFloatingAcc *arg1 = (iDynTree::FreeFloatingAcc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_FreeFloatingAcc",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__FreeFloatingAcc, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FreeFloatingAcc" "', argument " "1"" of type '" "iDynTree::FreeFloatingAcc *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::FreeFloatingAcc * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ContactWrench_contactPoint__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ContactWrench *arg1 = (iDynTree::ContactWrench *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("ContactWrench_contactPoint",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ContactWrench, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContactWrench_contactPoint" "', argument " "1"" of type '" "iDynTree::ContactWrench *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ContactWrench * >(argp1);
  result = (iDynTree::Position *) &(arg1)->contactPoint();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ContactWrench_contactWrench__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ContactWrench *arg1 = (iDynTree::ContactWrench *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Wrench *result = 0 ;
  
  if (!SWIG_check_num_args("ContactWrench_contactWrench",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ContactWrench, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContactWrench_contactWrench" "', argument " "1"" of type '" "iDynTree::ContactWrench *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ContactWrench * >(argp1);
  result = (iDynTree::Wrench *) &(arg1)->contactWrench();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Wrench, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ContactWrench_contactId(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ContactWrench *arg1 = (iDynTree::ContactWrench *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::size_t *result = 0 ;
  
  if (!SWIG_check_num_args("ContactWrench_contactId",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ContactWrench, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContactWrench_contactId" "', argument " "1"" of type '" "iDynTree::ContactWrench *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ContactWrench * >(argp1);
  result = (std::size_t *) &(arg1)->contactId();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__size_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ContactWrench_contactPoint__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ContactWrench *arg1 = (iDynTree::ContactWrench *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("ContactWrench_contactPoint",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ContactWrench, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContactWrench_contactPoint" "', argument " "1"" of type '" "iDynTree::ContactWrench const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ContactWrench * >(argp1);
  result = (iDynTree::Position *) &((iDynTree::ContactWrench const *)arg1)->contactPoint();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ContactWrench_contactPoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ContactWrench, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ContactWrench_contactPoint__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ContactWrench, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ContactWrench_contactPoint__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ContactWrench_contactPoint'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ContactWrench::contactPoint()\n"
    "    iDynTree::ContactWrench::contactPoint() const\n");
  return 1;
}


int _wrap_ContactWrench_contactWrench__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ContactWrench *arg1 = (iDynTree::ContactWrench *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Wrench *result = 0 ;
  
  if (!SWIG_check_num_args("ContactWrench_contactWrench",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ContactWrench, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContactWrench_contactWrench" "', argument " "1"" of type '" "iDynTree::ContactWrench const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ContactWrench * >(argp1);
  result = (iDynTree::Wrench *) &((iDynTree::ContactWrench const *)arg1)->contactWrench();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Wrench, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ContactWrench_contactWrench(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ContactWrench, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ContactWrench_contactWrench__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ContactWrench, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ContactWrench_contactWrench__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ContactWrench_contactWrench'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ContactWrench::contactWrench()\n"
    "    iDynTree::ContactWrench::contactWrench() const\n");
  return 1;
}


int _wrap_new_ContactWrench(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ContactWrench *result = 0 ;
  
  if (!SWIG_check_num_args("new_ContactWrench",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ContactWrench *)new iDynTree::ContactWrench();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ContactWrench, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ContactWrench(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ContactWrench *arg1 = (iDynTree::ContactWrench *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ContactWrench",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ContactWrench, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ContactWrench" "', argument " "1"" of type '" "iDynTree::ContactWrench *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ContactWrench * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkContactWrenches__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::LinkContactWrenches *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkContactWrenches",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinkContactWrenches" "', argument " "1"" of type '" "std::size_t""'");
  } 
  arg1 = static_cast< std::size_t >(val1);
  result = (iDynTree::LinkContactWrenches *)new iDynTree::LinkContactWrenches(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkContactWrenches, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkContactWrenches__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::LinkContactWrenches *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkContactWrenches",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::LinkContactWrenches *)new iDynTree::LinkContactWrenches();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkContactWrenches, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkContactWrenches__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkContactWrenches *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkContactWrenches",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinkContactWrenches" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinkContactWrenches" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::LinkContactWrenches *)new iDynTree::LinkContactWrenches((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkContactWrenches, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkContactWrenches(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_LinkContactWrenches__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LinkContactWrenches__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LinkContactWrenches__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_LinkContactWrenches'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkContactWrenches::LinkContactWrenches(std::size_t)\n"
    "    iDynTree::LinkContactWrenches::LinkContactWrenches()\n"
    "    iDynTree::LinkContactWrenches::LinkContactWrenches(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkContactWrenches_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkContactWrenches *arg1 = (iDynTree::LinkContactWrenches *) 0 ;
  std::size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkContactWrenches_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkContactWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkContactWrenches_resize" "', argument " "1"" of type '" "iDynTree::LinkContactWrenches *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkContactWrenches_resize" "', argument " "2"" of type '" "std::size_t""'");
  } 
  arg2 = static_cast< std::size_t >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkContactWrenches_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkContactWrenches *arg1 = (iDynTree::LinkContactWrenches *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkContactWrenches_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkContactWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkContactWrenches_resize" "', argument " "1"" of type '" "iDynTree::LinkContactWrenches *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkContactWrenches_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkContactWrenches_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkContactWrenches_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkContactWrenches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LinkContactWrenches_resize__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkContactWrenches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkContactWrenches_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkContactWrenches_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkContactWrenches::resize(std::size_t)\n"
    "    iDynTree::LinkContactWrenches::resize(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkContactWrenches_getNrOfContactsForLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkContactWrenches *arg1 = (iDynTree::LinkContactWrenches *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("LinkContactWrenches_getNrOfContactsForLink",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkContactWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkContactWrenches_getNrOfContactsForLink" "', argument " "1"" of type '" "iDynTree::LinkContactWrenches const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkContactWrenches_getNrOfContactsForLink" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = ((iDynTree::LinkContactWrenches const *)arg1)->getNrOfContactsForLink(arg2);
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkContactWrenches_setNrOfContactsForLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkContactWrenches *arg1 = (iDynTree::LinkContactWrenches *) 0 ;
  iDynTree::LinkIndex arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkContactWrenches_setNrOfContactsForLink",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkContactWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkContactWrenches_setNrOfContactsForLink" "', argument " "1"" of type '" "iDynTree::LinkContactWrenches *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkContactWrenches_setNrOfContactsForLink" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinkContactWrenches_setNrOfContactsForLink" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->setNrOfContactsForLink(arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkContactWrenches_getNrOfLinks(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkContactWrenches *arg1 = (iDynTree::LinkContactWrenches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("LinkContactWrenches_getNrOfLinks",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkContactWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkContactWrenches_getNrOfLinks" "', argument " "1"" of type '" "iDynTree::LinkContactWrenches const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp1);
  result = ((iDynTree::LinkContactWrenches const *)arg1)->getNrOfLinks();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkContactWrenches_contactWrench__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkContactWrenches *arg1 = (iDynTree::LinkContactWrenches *) 0 ;
  iDynTree::LinkIndex arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::ContactWrench *result = 0 ;
  
  if (!SWIG_check_num_args("LinkContactWrenches_contactWrench",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkContactWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkContactWrenches_contactWrench" "', argument " "1"" of type '" "iDynTree::LinkContactWrenches *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkContactWrenches_contactWrench" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinkContactWrenches_contactWrench" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  result = (iDynTree::ContactWrench *) &(arg1)->contactWrench(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ContactWrench, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkContactWrenches_contactWrench__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkContactWrenches *arg1 = (iDynTree::LinkContactWrenches *) 0 ;
  iDynTree::LinkIndex arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::ContactWrench *result = 0 ;
  
  if (!SWIG_check_num_args("LinkContactWrenches_contactWrench",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkContactWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkContactWrenches_contactWrench" "', argument " "1"" of type '" "iDynTree::LinkContactWrenches const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkContactWrenches_contactWrench" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinkContactWrenches_contactWrench" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  result = (iDynTree::ContactWrench *) &((iDynTree::LinkContactWrenches const *)arg1)->contactWrench(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ContactWrench, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkContactWrenches_contactWrench(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkContactWrenches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LinkContactWrenches_contactWrench__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkContactWrenches, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LinkContactWrenches_contactWrench__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkContactWrenches_contactWrench'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkContactWrenches::contactWrench(iDynTree::LinkIndex const,size_t const)\n"
    "    iDynTree::LinkContactWrenches::contactWrench(iDynTree::LinkIndex const,size_t const) const\n");
  return 1;
}


int _wrap_LinkContactWrenches_computeNetWrenches(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkContactWrenches *arg1 = (iDynTree::LinkContactWrenches *) 0 ;
  iDynTree::LinkNetExternalWrenches *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("LinkContactWrenches_computeNetWrenches",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkContactWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkContactWrenches_computeNetWrenches" "', argument " "1"" of type '" "iDynTree::LinkContactWrenches const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkContactWrenches_computeNetWrenches" "', argument " "2"" of type '" "iDynTree::LinkNetExternalWrenches &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkContactWrenches_computeNetWrenches" "', argument " "2"" of type '" "iDynTree::LinkNetExternalWrenches &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkNetExternalWrenches * >(argp2);
  result = (bool)((iDynTree::LinkContactWrenches const *)arg1)->computeNetWrenches(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkContactWrenches_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkContactWrenches *arg1 = (iDynTree::LinkContactWrenches *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("LinkContactWrenches_toString",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkContactWrenches, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkContactWrenches_toString" "', argument " "1"" of type '" "iDynTree::LinkContactWrenches const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkContactWrenches_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkContactWrenches_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = ((iDynTree::LinkContactWrenches const *)arg1)->toString((iDynTree::Model const &)*arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_LinkContactWrenches(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkContactWrenches *arg1 = (iDynTree::LinkContactWrenches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_LinkContactWrenches",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkContactWrenches, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinkContactWrenches" "', argument " "1"" of type '" "iDynTree::LinkContactWrenches *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_pop(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * >::value_type result;
  
  if (!SWIG_check_num_args("SolidShapesVector_pop",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_pop" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  try {
    result = (std::vector< iDynTree::SolidShape * >::value_type)std_vector_Sl_iDynTree_SolidShape_Sm__Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_brace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  std::vector< iDynTree::SolidShape * >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * >::value_type result;
  
  if (!SWIG_check_num_args("SolidShapesVector_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_brace" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SolidShapesVector_brace" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::SolidShape * >::difference_type >(val2);
  try {
    result = (std::vector< iDynTree::SolidShape * >::value_type)std_vector_Sl_iDynTree_SolidShape_Sm__Sg__brace(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_setbrace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  std::vector< iDynTree::SolidShape * >::value_type arg2 = (std::vector< iDynTree::SolidShape * >::value_type) 0 ;
  std::vector< iDynTree::SolidShape * >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SolidShapesVector_setbrace",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_setbrace" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SolidShapesVector_setbrace" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::value_type""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::SolidShape * >::value_type >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SolidShapesVector_setbrace" "', argument " "3"" of type '" "std::vector< iDynTree::SolidShape * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< iDynTree::SolidShape * >::difference_type >(val3);
  try {
    std_vector_Sl_iDynTree_SolidShape_Sm__Sg__setbrace(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_append(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  std::vector< iDynTree::SolidShape * >::value_type arg2 = (std::vector< iDynTree::SolidShape * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SolidShapesVector_append",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_append" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SolidShapesVector_append" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::value_type""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::SolidShape * >::value_type >(argp2);
  std_vector_Sl_iDynTree_SolidShape_Sm__Sg__append(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SolidShapesVector__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  std::vector< iDynTree::SolidShape * > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SolidShapesVector",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (std::vector< iDynTree::SolidShape * > *)new std::vector< iDynTree::SolidShape * >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SolidShapesVector__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SolidShapesVector",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *ptr = (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *)0;
    res1 = swig::asptr(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SolidShapesVector" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SolidShapesVector" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< iDynTree::SolidShape * > *)new std::vector< iDynTree::SolidShape * >((std::vector< iDynTree::SolidShape * > const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 0;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 1;
}


int _wrap_SolidShapesVector_empty(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SolidShapesVector_empty",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_empty" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  result = (bool)((std::vector< iDynTree::SolidShape * > const *)arg1)->empty();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * >::size_type result;
  
  if (!SWIG_check_num_args("SolidShapesVector_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_size" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  result = ((std::vector< iDynTree::SolidShape * > const *)arg1)->size();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_swap(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  std::vector< iDynTree::SolidShape * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SolidShapesVector_swap",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_swap" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SolidShapesVector_swap" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SolidShapesVector_swap" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp2);
  (arg1)->swap(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_begin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * >::iterator result;
  
  if (!SWIG_check_num_args("SolidShapesVector_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_begin" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  result = (arg1)->begin();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::SolidShape * >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_end(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * >::iterator result;
  
  if (!SWIG_check_num_args("SolidShapesVector_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_end" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  result = (arg1)->end();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::SolidShape * >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_rbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * >::reverse_iterator result;
  
  if (!SWIG_check_num_args("SolidShapesVector_rbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_rbegin" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  result = (arg1)->rbegin();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::SolidShape * >::reverse_iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_rend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * >::reverse_iterator result;
  
  if (!SWIG_check_num_args("SolidShapesVector_rend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_rend" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  result = (arg1)->rend();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::SolidShape * >::reverse_iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_clear(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SolidShapesVector_clear",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_clear" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  (arg1)->clear();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_get_allocator(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< std::allocator< iDynTree::SolidShape * > > result;
  
  if (!SWIG_check_num_args("SolidShapesVector_get_allocator",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_get_allocator" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  result = ((std::vector< iDynTree::SolidShape * > const *)arg1)->get_allocator();
  _out = SWIG_NewPointerObj((new std::vector< iDynTree::SolidShape * >::allocator_type(static_cast< const std::vector< iDynTree::SolidShape * >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_iDynTree__SolidShape_p_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SolidShapesVector__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SolidShapesVector",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SolidShapesVector" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * >::size_type""'");
  } 
  arg1 = static_cast< std::vector< iDynTree::SolidShape * >::size_type >(val1);
  result = (std::vector< iDynTree::SolidShape * > *)new std::vector< iDynTree::SolidShape * >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_pop_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SolidShapesVector_pop_back",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_pop_back" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  (arg1)->pop_back();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  std::vector< iDynTree::SolidShape * >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SolidShapesVector_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_resize" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SolidShapesVector_resize" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::SolidShape * >::size_type >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_erase__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  std::vector< iDynTree::SolidShape * >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * >::iterator result;
  
  if (!SWIG_check_num_args("SolidShapesVector_erase",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_erase" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SolidShapesVector_erase" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SolidShapesVector_erase" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::iterator""'");
    }
  }
  result = std_vector_Sl_iDynTree_SolidShape_Sm__Sg__erase__SWIG_0(arg1,arg2);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::SolidShape * >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_erase__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  std::vector< iDynTree::SolidShape * >::iterator arg2 ;
  std::vector< iDynTree::SolidShape * >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  swig::MatlabSwigIterator *iter3 = 0 ;
  int res3 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * >::iterator result;
  
  if (!SWIG_check_num_args("SolidShapesVector_erase",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_erase" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SolidShapesVector_erase" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SolidShapesVector_erase" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter3), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SolidShapesVector_erase" "', argument " "3"" of type '" "std::vector< iDynTree::SolidShape * >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SolidShapesVector_erase" "', argument " "3"" of type '" "std::vector< iDynTree::SolidShape * >::iterator""'");
    }
  }
  result = std_vector_Sl_iDynTree_SolidShape_Sm__Sg__erase__SWIG_1(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::SolidShape * >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_erase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_SolidShapesVector_erase__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *>(iter) != 0));
      if (_v) {
        swig::MatlabSwigIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_SolidShapesVector_erase__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SolidShapesVector_erase'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::SolidShape * >::erase(std::vector< iDynTree::SolidShape * >::iterator)\n"
    "    std::vector< iDynTree::SolidShape * >::erase(std::vector< iDynTree::SolidShape * >::iterator,std::vector< iDynTree::SolidShape * >::iterator)\n");
  return 1;
}


int _wrap_new_SolidShapesVector__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * >::size_type arg1 ;
  std::vector< iDynTree::SolidShape * >::value_type arg2 = (std::vector< iDynTree::SolidShape * >::value_type) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * > *result = 0 ;
  
  if (!SWIG_check_num_args("new_SolidShapesVector",argc,2,2,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SolidShapesVector" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * >::size_type""'");
  } 
  arg1 = static_cast< std::vector< iDynTree::SolidShape * >::size_type >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SolidShapesVector" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::value_type""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::SolidShape * >::value_type >(argp2);
  result = (std::vector< iDynTree::SolidShape * > *)new std::vector< iDynTree::SolidShape * >(arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SolidShapesVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_SolidShapesVector__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SolidShapesVector__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SolidShapesVector__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SolidShape, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SolidShapesVector__SWIG_3(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_SolidShapesVector'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::SolidShape * >::vector()\n"
    "    std::vector< iDynTree::SolidShape * >::vector(std::vector< iDynTree::SolidShape * > const &)\n"
    "    std::vector< iDynTree::SolidShape * >::vector(std::vector< iDynTree::SolidShape * >::size_type)\n"
    "    std::vector< iDynTree::SolidShape * >::vector(std::vector< iDynTree::SolidShape * >::size_type,std::vector< iDynTree::SolidShape * >::value_type)\n");
  return 1;
}


int _wrap_SolidShapesVector_push_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  std::vector< iDynTree::SolidShape * >::value_type arg2 = (std::vector< iDynTree::SolidShape * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SolidShapesVector_push_back",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_push_back" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SolidShapesVector_push_back" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::value_type""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::SolidShape * >::value_type >(argp2);
  (arg1)->push_back(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_front(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * >::value_type result;
  
  if (!SWIG_check_num_args("SolidShapesVector_front",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_front" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  result = (std::vector< iDynTree::SolidShape * >::value_type)((std::vector< iDynTree::SolidShape * > const *)arg1)->front();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * >::value_type result;
  
  if (!SWIG_check_num_args("SolidShapesVector_back",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_back" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  result = (std::vector< iDynTree::SolidShape * >::value_type)((std::vector< iDynTree::SolidShape * > const *)arg1)->back();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_assign(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  std::vector< iDynTree::SolidShape * >::size_type arg2 ;
  std::vector< iDynTree::SolidShape * >::value_type arg3 = (std::vector< iDynTree::SolidShape * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SolidShapesVector_assign",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_assign" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SolidShapesVector_assign" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::SolidShape * >::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SolidShapesVector_assign" "', argument " "3"" of type '" "std::vector< iDynTree::SolidShape * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< iDynTree::SolidShape * >::value_type >(argp3);
  (arg1)->assign(arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  std::vector< iDynTree::SolidShape * >::size_type arg2 ;
  std::vector< iDynTree::SolidShape * >::value_type arg3 = (std::vector< iDynTree::SolidShape * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SolidShapesVector_resize",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_resize" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SolidShapesVector_resize" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::SolidShape * >::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SolidShapesVector_resize" "', argument " "3"" of type '" "std::vector< iDynTree::SolidShape * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< iDynTree::SolidShape * >::value_type >(argp3);
  (arg1)->resize(arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SolidShapesVector_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SolidShape, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SolidShapesVector_resize__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SolidShapesVector_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::SolidShape * >::resize(std::vector< iDynTree::SolidShape * >::size_type)\n"
    "    std::vector< iDynTree::SolidShape * >::resize(std::vector< iDynTree::SolidShape * >::size_type,std::vector< iDynTree::SolidShape * >::value_type)\n");
  return 1;
}


int _wrap_SolidShapesVector_insert__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  std::vector< iDynTree::SolidShape * >::iterator arg2 ;
  std::vector< iDynTree::SolidShape * >::value_type arg3 = (std::vector< iDynTree::SolidShape * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * >::iterator result;
  
  if (!SWIG_check_num_args("SolidShapesVector_insert",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_insert" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SolidShapesVector_insert" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SolidShapesVector_insert" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SolidShapesVector_insert" "', argument " "3"" of type '" "std::vector< iDynTree::SolidShape * >::value_type""'"); 
  }
  arg3 = reinterpret_cast< std::vector< iDynTree::SolidShape * >::value_type >(argp3);
  result = std_vector_Sl_iDynTree_SolidShape_Sm__Sg__insert__SWIG_0(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::SolidShape * >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_insert__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  std::vector< iDynTree::SolidShape * >::iterator arg2 ;
  std::vector< iDynTree::SolidShape * >::size_type arg3 ;
  std::vector< iDynTree::SolidShape * >::value_type arg4 = (std::vector< iDynTree::SolidShape * >::value_type) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SolidShapesVector_insert",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_insert" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SolidShapesVector_insert" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SolidShapesVector_insert" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SolidShapesVector_insert" "', argument " "3"" of type '" "std::vector< iDynTree::SolidShape * >::size_type""'");
  } 
  arg3 = static_cast< std::vector< iDynTree::SolidShape * >::size_type >(val3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_iDynTree__SolidShape, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SolidShapesVector_insert" "', argument " "4"" of type '" "std::vector< iDynTree::SolidShape * >::value_type""'"); 
  }
  arg4 = reinterpret_cast< std::vector< iDynTree::SolidShape * >::value_type >(argp4);
  std_vector_Sl_iDynTree_SolidShape_Sm__Sg__insert__SWIG_1(arg1,arg2,arg3,arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_insert(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *>(iter) != 0));
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SolidShape, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SolidShapesVector_insert__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::SolidShape * >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__SolidShape, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SolidShapesVector_insert__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SolidShapesVector_insert'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::SolidShape * >::insert(std::vector< iDynTree::SolidShape * >::iterator,std::vector< iDynTree::SolidShape * >::value_type)\n"
    "    std::vector< iDynTree::SolidShape * >::insert(std::vector< iDynTree::SolidShape * >::iterator,std::vector< iDynTree::SolidShape * >::size_type,std::vector< iDynTree::SolidShape * >::value_type)\n");
  return 1;
}


int _wrap_SolidShapesVector_reserve(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  std::vector< iDynTree::SolidShape * >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("SolidShapesVector_reserve",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_reserve" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SolidShapesVector_reserve" "', argument " "2"" of type '" "std::vector< iDynTree::SolidShape * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::SolidShape * >::size_type >(val2);
  (arg1)->reserve(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SolidShapesVector_capacity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::SolidShape * >::size_type result;
  
  if (!SWIG_check_num_args("SolidShapesVector_capacity",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SolidShapesVector_capacity" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  result = ((std::vector< iDynTree::SolidShape * > const *)arg1)->capacity();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_SolidShapesVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::SolidShape * > *arg1 = (std::vector< iDynTree::SolidShape * > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SolidShapesVector",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SolidShapesVector" "', argument " "1"" of type '" "std::vector< iDynTree::SolidShape * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::SolidShape * > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_pop(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > >::value_type result;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_pop",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_pop" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  try {
    result = std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = swig::from(static_cast< std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_brace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > >::value_type result;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_brace" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinksSolidShapesVector_brace" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< iDynTree::SolidShape * > >::difference_type >(val2);
  try {
    result = std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__brace(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = swig::from(static_cast< std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_setbrace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::value_type arg2 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_setbrace",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_setbrace" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  {
    std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *ptr = (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *)0;
    int res = swig::asptr(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LinksSolidShapesVector_setbrace" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::value_type""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinksSolidShapesVector_setbrace" "', argument " "3"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< iDynTree::SolidShape * > >::difference_type >(val3);
  try {
    std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__setbrace(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_append(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_append",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_append" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  {
    std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *ptr = (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *)0;
    int res = swig::asptr(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "LinksSolidShapesVector_append" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::value_type""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__append(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinksSolidShapesVector__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > > *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinksSolidShapesVector",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (std::vector< std::vector< iDynTree::SolidShape * > > *)new std::vector< std::vector< iDynTree::SolidShape * > >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinksSolidShapesVector__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > > *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinksSolidShapesVector",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > > *ptr = (std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > > *)0;
    res1 = swig::asptr(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinksSolidShapesVector" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinksSolidShapesVector" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< std::vector< iDynTree::SolidShape * > > *)new std::vector< std::vector< iDynTree::SolidShape * > >((std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 0;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 1;
}


int _wrap_LinksSolidShapesVector_empty(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_empty",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_empty" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  result = (bool)((std::vector< std::vector< iDynTree::SolidShape * > > const *)arg1)->empty();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > >::size_type result;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_size" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  result = ((std::vector< std::vector< iDynTree::SolidShape * > > const *)arg1)->size();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_swap(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_swap",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_swap" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinksSolidShapesVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinksSolidShapesVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > * >(argp2);
  (arg1)->swap(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_begin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > >::iterator result;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_begin" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  result = (arg1)->begin();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< iDynTree::SolidShape * > >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_end(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > >::iterator result;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_end" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  result = (arg1)->end();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< iDynTree::SolidShape * > >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_rbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > >::reverse_iterator result;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_rbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_rbegin" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  result = (arg1)->rbegin();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< iDynTree::SolidShape * > >::reverse_iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_rend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > >::reverse_iterator result;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_rend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_rend" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  result = (arg1)->rend();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< iDynTree::SolidShape * > >::reverse_iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_clear(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_clear",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_clear" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  (arg1)->clear();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_get_allocator(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > > result;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_get_allocator",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  result = ((std::vector< std::vector< iDynTree::SolidShape * > > const *)arg1)->get_allocator();
  _out = SWIG_NewPointerObj((new std::vector< std::vector< iDynTree::SolidShape * > >::allocator_type(static_cast< const std::vector< std::vector< iDynTree::SolidShape * > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinksSolidShapesVector__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > > *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinksSolidShapesVector",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinksSolidShapesVector" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< iDynTree::SolidShape * > >::size_type >(val1);
  result = (std::vector< std::vector< iDynTree::SolidShape * > > *)new std::vector< std::vector< iDynTree::SolidShape * > >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_pop_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_pop_back",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_pop_back" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  (arg1)->pop_back();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinksSolidShapesVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< iDynTree::SolidShape * > >::size_type >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_erase__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > >::iterator result;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_erase",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinksSolidShapesVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinksSolidShapesVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::iterator""'");
    }
  }
  result = std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__erase__SWIG_0(arg1,arg2);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< iDynTree::SolidShape * > >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_erase__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::iterator arg2 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  swig::MatlabSwigIterator *iter3 = 0 ;
  int res3 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > >::iterator result;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_erase",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinksSolidShapesVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinksSolidShapesVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter3), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinksSolidShapesVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinksSolidShapesVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::iterator""'");
    }
  }
  result = std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__erase__SWIG_1(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< iDynTree::SolidShape * > >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_erase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_LinksSolidShapesVector_erase__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::MatlabSwigIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_LinksSolidShapesVector_erase__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinksSolidShapesVector_erase'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< iDynTree::SolidShape * > >::erase(std::vector< std::vector< iDynTree::SolidShape * > >::iterator)\n"
    "    std::vector< std::vector< iDynTree::SolidShape * > >::erase(std::vector< std::vector< iDynTree::SolidShape * > >::iterator,std::vector< std::vector< iDynTree::SolidShape * > >::iterator)\n");
  return 1;
}


int _wrap_new_LinksSolidShapesVector__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > >::size_type arg1 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > > *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinksSolidShapesVector",argc,2,2,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinksSolidShapesVector" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< iDynTree::SolidShape * > >::size_type >(val1);
  {
    std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *ptr = (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *)0;
    res2 = swig::asptr(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinksSolidShapesVector" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinksSolidShapesVector" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  result = (std::vector< std::vector< iDynTree::SolidShape * > > *)new std::vector< std::vector< iDynTree::SolidShape * > >(arg1,(std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_new_LinksSolidShapesVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_LinksSolidShapesVector__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LinksSolidShapesVector__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LinksSolidShapesVector__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_LinksSolidShapesVector__SWIG_3(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_LinksSolidShapesVector'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< iDynTree::SolidShape * > >::vector()\n"
    "    std::vector< std::vector< iDynTree::SolidShape * > >::vector(std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > const &)\n"
    "    std::vector< std::vector< iDynTree::SolidShape * > >::vector(std::vector< std::vector< iDynTree::SolidShape * > >::size_type)\n"
    "    std::vector< std::vector< iDynTree::SolidShape * > >::vector(std::vector< std::vector< iDynTree::SolidShape * > >::size_type,std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &)\n");
  return 1;
}


int _wrap_LinksSolidShapesVector_push_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_push_back",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_push_back" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  {
    std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *ptr = (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *)0;
    res2 = swig::asptr(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinksSolidShapesVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinksSolidShapesVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->push_back((std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_LinksSolidShapesVector_front(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > >::value_type *result = 0 ;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_front",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_front" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  result = (std::vector< std::vector< iDynTree::SolidShape * > >::value_type *) &((std::vector< std::vector< iDynTree::SolidShape * > > const *)arg1)->front();
  _out = swig::from(static_cast< std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > >::value_type *result = 0 ;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_back",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_back" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  result = (std::vector< std::vector< iDynTree::SolidShape * > >::value_type *) &((std::vector< std::vector< iDynTree::SolidShape * > > const *)arg1)->back();
  _out = swig::from(static_cast< std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_assign(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::size_type arg2 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_assign",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_assign" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinksSolidShapesVector_assign" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< iDynTree::SolidShape * > >::size_type >(val2);
  {
    std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *ptr = (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinksSolidShapesVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinksSolidShapesVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->assign(arg2,(std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_LinksSolidShapesVector_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::size_type arg2 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_resize",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinksSolidShapesVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< iDynTree::SolidShape * > >::size_type >(val2);
  {
    std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *ptr = (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinksSolidShapesVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinksSolidShapesVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  (arg1)->resize(arg2,(std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_LinksSolidShapesVector_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinksSolidShapesVector_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LinksSolidShapesVector_resize__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinksSolidShapesVector_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< iDynTree::SolidShape * > >::resize(std::vector< std::vector< iDynTree::SolidShape * > >::size_type)\n"
    "    std::vector< std::vector< iDynTree::SolidShape * > >::resize(std::vector< std::vector< iDynTree::SolidShape * > >::size_type,std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &)\n");
  return 1;
}


int _wrap_LinksSolidShapesVector_insert__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::iterator arg2 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > >::iterator result;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_insert",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinksSolidShapesVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinksSolidShapesVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::iterator""'");
    }
  }
  {
    std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *ptr = (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinksSolidShapesVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinksSolidShapesVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  result = std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__insert__SWIG_0(arg1,arg2,(std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > const &)*arg3);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< iDynTree::SolidShape * > >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_LinksSolidShapesVector_insert__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::iterator arg2 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::size_type arg3 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_insert",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinksSolidShapesVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "LinksSolidShapesVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinksSolidShapesVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< iDynTree::SolidShape * > >::size_type >(val3);
  {
    std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *ptr = (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > > *)0;
    res4 = swig::asptr(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LinksSolidShapesVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinksSolidShapesVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  std_vector_Sl_std_vector_Sl_iDynTree_SolidShape_Sm__Sg__Sg__insert__SWIG_1(arg1,arg2,arg3,(std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > const &)*arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return 0;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return 1;
}


int _wrap_LinksSolidShapesVector_insert(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LinksSolidShapesVector_insert__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< std::vector< iDynTree::SolidShape * > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< iDynTree::SolidShape*,std::allocator< iDynTree::SolidShape * > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_LinksSolidShapesVector_insert__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinksSolidShapesVector_insert'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< iDynTree::SolidShape * > >::insert(std::vector< std::vector< iDynTree::SolidShape * > >::iterator,std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &)\n"
    "    std::vector< std::vector< iDynTree::SolidShape * > >::insert(std::vector< std::vector< iDynTree::SolidShape * > >::iterator,std::vector< std::vector< iDynTree::SolidShape * > >::size_type,std::vector< std::vector< iDynTree::SolidShape * > >::value_type const &)\n");
  return 1;
}


int _wrap_LinksSolidShapesVector_reserve(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  std::vector< std::vector< iDynTree::SolidShape * > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_reserve",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_reserve" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinksSolidShapesVector_reserve" "', argument " "2"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< iDynTree::SolidShape * > >::size_type >(val2);
  (arg1)->reserve(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinksSolidShapesVector_capacity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::vector< iDynTree::SolidShape * > >::size_type result;
  
  if (!SWIG_check_num_args("LinksSolidShapesVector_capacity",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinksSolidShapesVector_capacity" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  result = ((std::vector< std::vector< iDynTree::SolidShape * > > const *)arg1)->capacity();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_LinksSolidShapesVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< std::vector< iDynTree::SolidShape * > > *arg1 = (std::vector< std::vector< iDynTree::SolidShape * > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_LinksSolidShapesVector",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinksSolidShapesVector" "', argument " "1"" of type '" "std::vector< std::vector< iDynTree::SolidShape * > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< iDynTree::SolidShape * > > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ForwardPositionKinematics__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  iDynTree::LinkPositions *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ForwardPositionKinematics",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardPositionKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPositionKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ForwardPositionKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPositionKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ForwardPositionKinematics" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPositionKinematics" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ForwardPositionKinematics" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPositionKinematics" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkPositions,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ForwardPositionKinematics" "', argument " "5"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPositionKinematics" "', argument " "5"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkPositions * >(argp5);
  result = (bool)iDynTree::ForwardPositionKinematics((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::Transform const &)*arg3,(iDynTree::VectorDynSize const &)*arg4,*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ForwardPositionKinematics__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::FreeFloatingPos *arg3 = 0 ;
  iDynTree::LinkPositions *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ForwardPositionKinematics",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardPositionKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPositionKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ForwardPositionKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPositionKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__FreeFloatingPos,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ForwardPositionKinematics" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPositionKinematics" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkPositions,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ForwardPositionKinematics" "', argument " "4"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPositionKinematics" "', argument " "4"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkPositions * >(argp4);
  result = (bool)iDynTree::ForwardPositionKinematics((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::FreeFloatingPos const &)*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ForwardPositionKinematics(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Traversal, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingPos, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__LinkPositions, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ForwardPositionKinematics__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Traversal, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__LinkPositions, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ForwardPositionKinematics__SWIG_0(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ForwardPositionKinematics'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ForwardPositionKinematics(iDynTree::Model const &,iDynTree::Traversal const &,iDynTree::Transform const &,iDynTree::VectorDynSize const &,iDynTree::LinkPositions &)\n"
    "    iDynTree::ForwardPositionKinematics(iDynTree::Model const &,iDynTree::Traversal const &,iDynTree::FreeFloatingPos const &,iDynTree::LinkPositions &)\n");
  return 1;
}


int _wrap_ForwardVelAccKinematics(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::FreeFloatingPos *arg3 = 0 ;
  iDynTree::FreeFloatingVel *arg4 = 0 ;
  iDynTree::FreeFloatingAcc *arg5 = 0 ;
  iDynTree::LinkVelArray *arg6 = 0 ;
  iDynTree::LinkAccArray *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ForwardVelAccKinematics",argc,7,7,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardVelAccKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardVelAccKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ForwardVelAccKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardVelAccKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__FreeFloatingPos,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ForwardVelAccKinematics" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardVelAccKinematics" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__FreeFloatingVel,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ForwardVelAccKinematics" "', argument " "4"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardVelAccKinematics" "', argument " "4"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__FreeFloatingAcc,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ForwardVelAccKinematics" "', argument " "5"" of type '" "iDynTree::FreeFloatingAcc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardVelAccKinematics" "', argument " "5"" of type '" "iDynTree::FreeFloatingAcc const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::FreeFloatingAcc * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ForwardVelAccKinematics" "', argument " "6"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardVelAccKinematics" "', argument " "6"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkVelArray * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ForwardVelAccKinematics" "', argument " "7"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardVelAccKinematics" "', argument " "7"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::LinkAccArray * >(argp7);
  result = (bool)iDynTree::ForwardVelAccKinematics((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::FreeFloatingPos const &)*arg3,(iDynTree::FreeFloatingVel const &)*arg4,(iDynTree::FreeFloatingAcc const &)*arg5,*arg6,*arg7);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ForwardPosVelAccKinematics(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::FreeFloatingPos *arg3 = 0 ;
  iDynTree::FreeFloatingVel *arg4 = 0 ;
  iDynTree::FreeFloatingAcc *arg5 = 0 ;
  iDynTree::LinkPositions *arg6 = 0 ;
  iDynTree::LinkVelArray *arg7 = 0 ;
  iDynTree::LinkAccArray *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ForwardPosVelAccKinematics",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardPosVelAccKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPosVelAccKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ForwardPosVelAccKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPosVelAccKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__FreeFloatingPos,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ForwardPosVelAccKinematics" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPosVelAccKinematics" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__FreeFloatingVel,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ForwardPosVelAccKinematics" "', argument " "4"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPosVelAccKinematics" "', argument " "4"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__FreeFloatingAcc,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ForwardPosVelAccKinematics" "', argument " "5"" of type '" "iDynTree::FreeFloatingAcc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPosVelAccKinematics" "', argument " "5"" of type '" "iDynTree::FreeFloatingAcc const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::FreeFloatingAcc * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkPositions,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ForwardPosVelAccKinematics" "', argument " "6"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPosVelAccKinematics" "', argument " "6"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkPositions * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ForwardPosVelAccKinematics" "', argument " "7"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPosVelAccKinematics" "', argument " "7"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::LinkVelArray * >(argp7);
  res8 = SWIG_ConvertPtr(argv[7], &argp8, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ForwardPosVelAccKinematics" "', argument " "8"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPosVelAccKinematics" "', argument " "8"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg8 = reinterpret_cast< iDynTree::LinkAccArray * >(argp8);
  result = (bool)iDynTree::ForwardPosVelAccKinematics((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::FreeFloatingPos const &)*arg3,(iDynTree::FreeFloatingVel const &)*arg4,(iDynTree::FreeFloatingAcc const &)*arg5,*arg6,*arg7,*arg8);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ForwardPosVelKinematics(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::FreeFloatingPos *arg3 = 0 ;
  iDynTree::FreeFloatingVel *arg4 = 0 ;
  iDynTree::LinkPositions *arg5 = 0 ;
  iDynTree::LinkVelArray *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ForwardPosVelKinematics",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardPosVelKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPosVelKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ForwardPosVelKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPosVelKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__FreeFloatingPos,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ForwardPosVelKinematics" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPosVelKinematics" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__FreeFloatingVel,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ForwardPosVelKinematics" "', argument " "4"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPosVelKinematics" "', argument " "4"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkPositions,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ForwardPosVelKinematics" "', argument " "5"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPosVelKinematics" "', argument " "5"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkPositions * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ForwardPosVelKinematics" "', argument " "6"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardPosVelKinematics" "', argument " "6"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkVelArray * >(argp6);
  result = (bool)iDynTree::ForwardPosVelKinematics((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::FreeFloatingPos const &)*arg3,(iDynTree::FreeFloatingVel const &)*arg4,*arg5,*arg6);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ForwardAccKinematics(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::FreeFloatingPos *arg3 = 0 ;
  iDynTree::FreeFloatingVel *arg4 = 0 ;
  iDynTree::FreeFloatingAcc *arg5 = 0 ;
  iDynTree::LinkVelArray *arg6 = 0 ;
  iDynTree::LinkAccArray *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ForwardAccKinematics",argc,7,7,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardAccKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardAccKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ForwardAccKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardAccKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__FreeFloatingPos,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ForwardAccKinematics" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardAccKinematics" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__FreeFloatingVel,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ForwardAccKinematics" "', argument " "4"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardAccKinematics" "', argument " "4"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__FreeFloatingAcc,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ForwardAccKinematics" "', argument " "5"" of type '" "iDynTree::FreeFloatingAcc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardAccKinematics" "', argument " "5"" of type '" "iDynTree::FreeFloatingAcc const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::FreeFloatingAcc * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ForwardAccKinematics" "', argument " "6"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardAccKinematics" "', argument " "6"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkVelArray * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ForwardAccKinematics" "', argument " "7"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardAccKinematics" "', argument " "7"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::LinkAccArray * >(argp7);
  result = (bool)iDynTree::ForwardAccKinematics((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::FreeFloatingPos const &)*arg3,(iDynTree::FreeFloatingVel const &)*arg4,(iDynTree::FreeFloatingAcc const &)*arg5,(iDynTree::LinkVelArray const &)*arg6,*arg7);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ForwardBiasAccKinematics__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::FreeFloatingPos *arg3 = 0 ;
  iDynTree::FreeFloatingVel *arg4 = 0 ;
  iDynTree::SpatialAcc *arg5 = 0 ;
  iDynTree::LinkVelArray *arg6 = 0 ;
  iDynTree::LinkAccArray *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ForwardBiasAccKinematics",argc,7,7,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardBiasAccKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardBiasAccKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ForwardBiasAccKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardBiasAccKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__FreeFloatingPos,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ForwardBiasAccKinematics" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardBiasAccKinematics" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__FreeFloatingVel,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ForwardBiasAccKinematics" "', argument " "4"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardBiasAccKinematics" "', argument " "4"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ForwardBiasAccKinematics" "', argument " "5"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardBiasAccKinematics" "', argument " "5"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::SpatialAcc * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ForwardBiasAccKinematics" "', argument " "6"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardBiasAccKinematics" "', argument " "6"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkVelArray * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ForwardBiasAccKinematics" "', argument " "7"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardBiasAccKinematics" "', argument " "7"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::LinkAccArray * >(argp7);
  result = (bool)iDynTree::ForwardBiasAccKinematics((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::FreeFloatingPos const &)*arg3,(iDynTree::FreeFloatingVel const &)*arg4,(iDynTree::SpatialAcc const &)*arg5,(iDynTree::LinkVelArray const &)*arg6,*arg7);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ForwardBiasAccKinematics__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::FreeFloatingPos *arg3 = 0 ;
  iDynTree::FreeFloatingVel *arg4 = 0 ;
  iDynTree::LinkVelArray *arg5 = 0 ;
  iDynTree::LinkAccArray *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ForwardBiasAccKinematics",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardBiasAccKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardBiasAccKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ForwardBiasAccKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardBiasAccKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__FreeFloatingPos,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ForwardBiasAccKinematics" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardBiasAccKinematics" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__FreeFloatingVel,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ForwardBiasAccKinematics" "', argument " "4"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardBiasAccKinematics" "', argument " "4"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ForwardBiasAccKinematics" "', argument " "5"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardBiasAccKinematics" "', argument " "5"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkVelArray * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ForwardBiasAccKinematics" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ForwardBiasAccKinematics" "', argument " "6"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkAccArray * >(argp6);
  result = (bool)iDynTree::ForwardBiasAccKinematics((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::FreeFloatingPos const &)*arg3,(iDynTree::FreeFloatingVel const &)*arg4,(iDynTree::LinkVelArray const &)*arg5,*arg6);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ForwardBiasAccKinematics(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Traversal, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingPos, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingVel, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__LinkVelArray, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_iDynTree__LinkAccArray, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_ForwardBiasAccKinematics__SWIG_1(resc,resv,argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Traversal, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingPos, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingVel, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__SpatialAcc, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_iDynTree__LinkVelArray, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_iDynTree__LinkAccArray, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_ForwardBiasAccKinematics__SWIG_0(resc,resv,argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ForwardBiasAccKinematics'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ForwardBiasAccKinematics(iDynTree::Model const &,iDynTree::Traversal const &,iDynTree::FreeFloatingPos const &,iDynTree::FreeFloatingVel const &,iDynTree::SpatialAcc const &,iDynTree::LinkVelArray const &,iDynTree::LinkAccArray &)\n"
    "    iDynTree::ForwardBiasAccKinematics(iDynTree::Model const &,iDynTree::Traversal const &,iDynTree::FreeFloatingPos const &,iDynTree::FreeFloatingVel const &,iDynTree::LinkVelArray const &,iDynTree::LinkAccArray &)\n");
  return 1;
}


int _wrap_ComputeLinearAndAngularMomentum(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::LinkPositions *arg2 = 0 ;
  iDynTree::LinkVelArray *arg3 = 0 ;
  iDynTree::SpatialMomentum *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ComputeLinearAndAngularMomentum",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComputeLinearAndAngularMomentum" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComputeLinearAndAngularMomentum" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__LinkPositions,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComputeLinearAndAngularMomentum" "', argument " "2"" of type '" "iDynTree::LinkPositions const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComputeLinearAndAngularMomentum" "', argument " "2"" of type '" "iDynTree::LinkPositions const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkPositions * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ComputeLinearAndAngularMomentum" "', argument " "3"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComputeLinearAndAngularMomentum" "', argument " "3"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::LinkVelArray * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__SpatialMomentum,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ComputeLinearAndAngularMomentum" "', argument " "4"" of type '" "iDynTree::SpatialMomentum &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComputeLinearAndAngularMomentum" "', argument " "4"" of type '" "iDynTree::SpatialMomentum &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::SpatialMomentum * >(argp4);
  result = (bool)iDynTree::ComputeLinearAndAngularMomentum((iDynTree::Model const &)*arg1,(iDynTree::LinkPositions const &)*arg2,(iDynTree::LinkVelArray const &)*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ComputeLinearAndAngularMomentumDerivativeBias(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::LinkPositions *arg2 = 0 ;
  iDynTree::LinkVelArray *arg3 = 0 ;
  iDynTree::LinkAccArray *arg4 = 0 ;
  iDynTree::Wrench *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ComputeLinearAndAngularMomentumDerivativeBias",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComputeLinearAndAngularMomentumDerivativeBias" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComputeLinearAndAngularMomentumDerivativeBias" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__LinkPositions,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComputeLinearAndAngularMomentumDerivativeBias" "', argument " "2"" of type '" "iDynTree::LinkPositions const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComputeLinearAndAngularMomentumDerivativeBias" "', argument " "2"" of type '" "iDynTree::LinkPositions const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkPositions * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ComputeLinearAndAngularMomentumDerivativeBias" "', argument " "3"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComputeLinearAndAngularMomentumDerivativeBias" "', argument " "3"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::LinkVelArray * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ComputeLinearAndAngularMomentumDerivativeBias" "', argument " "4"" of type '" "iDynTree::LinkAccArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComputeLinearAndAngularMomentumDerivativeBias" "', argument " "4"" of type '" "iDynTree::LinkAccArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkAccArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ComputeLinearAndAngularMomentumDerivativeBias" "', argument " "5"" of type '" "iDynTree::Wrench &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComputeLinearAndAngularMomentumDerivativeBias" "', argument " "5"" of type '" "iDynTree::Wrench &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::Wrench * >(argp5);
  result = (bool)iDynTree::ComputeLinearAndAngularMomentumDerivativeBias((iDynTree::Model const &)*arg1,(iDynTree::LinkPositions const &)*arg2,(iDynTree::LinkVelArray const &)*arg3,(iDynTree::LinkAccArray const &)*arg4,*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_RNEADynamicPhase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::JointPosDoubleArray *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::LinkAccArray *arg5 = 0 ;
  iDynTree::LinkNetExternalWrenches *arg6 = 0 ;
  iDynTree::LinkInternalWrenches *arg7 = 0 ;
  iDynTree::FreeFloatingGeneralizedTorques *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("RNEADynamicPhase",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RNEADynamicPhase" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RNEADynamicPhase" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RNEADynamicPhase" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RNEADynamicPhase" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__JointPosDoubleArray,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RNEADynamicPhase" "', argument " "3"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RNEADynamicPhase" "', argument " "3"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RNEADynamicPhase" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RNEADynamicPhase" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "RNEADynamicPhase" "', argument " "5"" of type '" "iDynTree::LinkAccArray const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RNEADynamicPhase" "', argument " "5"" of type '" "iDynTree::LinkAccArray const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkAccArray * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "RNEADynamicPhase" "', argument " "6"" of type '" "iDynTree::LinkNetExternalWrenches const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RNEADynamicPhase" "', argument " "6"" of type '" "iDynTree::LinkNetExternalWrenches const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkNetExternalWrenches * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "RNEADynamicPhase" "', argument " "7"" of type '" "iDynTree::LinkInternalWrenches &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RNEADynamicPhase" "', argument " "7"" of type '" "iDynTree::LinkInternalWrenches &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::LinkInternalWrenches * >(argp7);
  res8 = SWIG_ConvertPtr(argv[7], &argp8, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "RNEADynamicPhase" "', argument " "8"" of type '" "iDynTree::FreeFloatingGeneralizedTorques &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RNEADynamicPhase" "', argument " "8"" of type '" "iDynTree::FreeFloatingGeneralizedTorques &""'"); 
  }
  arg8 = reinterpret_cast< iDynTree::FreeFloatingGeneralizedTorques * >(argp8);
  result = (bool)iDynTree::RNEADynamicPhase((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::JointPosDoubleArray const &)*arg3,(iDynTree::LinkVelArray const &)*arg4,(iDynTree::LinkAccArray const &)*arg5,(iDynTree::LinkWrenches const &)*arg6,*arg7,*arg8);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_CompositeRigidBodyAlgorithm(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::JointPosDoubleArray *arg3 = 0 ;
  iDynTree::LinkCompositeRigidBodyInertias *arg4 = 0 ;
  iDynTree::FreeFloatingMassMatrix *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("CompositeRigidBodyAlgorithm",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositeRigidBodyAlgorithm" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CompositeRigidBodyAlgorithm" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CompositeRigidBodyAlgorithm" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CompositeRigidBodyAlgorithm" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__JointPosDoubleArray,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CompositeRigidBodyAlgorithm" "', argument " "3"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CompositeRigidBodyAlgorithm" "', argument " "3"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkInertias,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CompositeRigidBodyAlgorithm" "', argument " "4"" of type '" "iDynTree::LinkCompositeRigidBodyInertias &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CompositeRigidBodyAlgorithm" "', argument " "4"" of type '" "iDynTree::LinkCompositeRigidBodyInertias &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkCompositeRigidBodyInertias * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__FreeFloatingMassMatrix,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CompositeRigidBodyAlgorithm" "', argument " "5"" of type '" "iDynTree::FreeFloatingMassMatrix &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CompositeRigidBodyAlgorithm" "', argument " "5"" of type '" "iDynTree::FreeFloatingMassMatrix &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::FreeFloatingMassMatrix * >(argp5);
  result = (bool)iDynTree::CompositeRigidBodyAlgorithm((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::JointPosDoubleArray const &)*arg3,*arg4,*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ArticulatedBodyAlgorithmInternalBuffers__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *result = 0 ;
  
  if (!SWIG_check_num_args("new_ArticulatedBodyAlgorithmInternalBuffers",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *)new iDynTree::ArticulatedBodyAlgorithmInternalBuffers();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ArticulatedBodyAlgorithmInternalBuffers__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *result = 0 ;
  
  if (!SWIG_check_num_args("new_ArticulatedBodyAlgorithmInternalBuffers",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ArticulatedBodyAlgorithmInternalBuffers" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ArticulatedBodyAlgorithmInternalBuffers" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *)new iDynTree::ArticulatedBodyAlgorithmInternalBuffers((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ArticulatedBodyAlgorithmInternalBuffers(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_ArticulatedBodyAlgorithmInternalBuffers__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ArticulatedBodyAlgorithmInternalBuffers__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_ArticulatedBodyAlgorithmInternalBuffers'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ArticulatedBodyAlgorithmInternalBuffers::ArticulatedBodyAlgorithmInternalBuffers()\n"
    "    iDynTree::ArticulatedBodyAlgorithmInternalBuffers::ArticulatedBodyAlgorithmInternalBuffers(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_resize" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyAlgorithmInternalBuffers_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_isConsistent" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyAlgorithmInternalBuffers_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)(arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_S_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  iDynTree::DOFSpatialMotionArray *arg2 = (iDynTree::DOFSpatialMotionArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_S_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_S_set" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_S_set" "', argument " "2"" of type '" "iDynTree::DOFSpatialMotionArray *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::DOFSpatialMotionArray * >(argp2);
  if (arg1) (arg1)->S = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_S_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::DOFSpatialMotionArray *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_S_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_S_get" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  result = (iDynTree::DOFSpatialMotionArray *)& ((arg1)->S);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__DOFSpatialMotionArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_U_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  iDynTree::DOFSpatialForceArray *arg2 = (iDynTree::DOFSpatialForceArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_U_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_U_set" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__DOFSpatialForceArray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_U_set" "', argument " "2"" of type '" "iDynTree::DOFSpatialForceArray *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::DOFSpatialForceArray * >(argp2);
  if (arg1) (arg1)->U = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_U_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::DOFSpatialForceArray *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_U_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_U_get" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  result = (iDynTree::DOFSpatialForceArray *)& ((arg1)->U);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__DOFSpatialForceArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_D_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  iDynTree::JointDOFsDoubleArray *arg2 = (iDynTree::JointDOFsDoubleArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_D_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_D_set" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_D_set" "', argument " "2"" of type '" "iDynTree::JointDOFsDoubleArray *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp2);
  if (arg1) (arg1)->D = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_D_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointDOFsDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_D_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_D_get" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  result = (iDynTree::JointDOFsDoubleArray *)& ((arg1)->D);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_u_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  iDynTree::JointDOFsDoubleArray *arg2 = (iDynTree::JointDOFsDoubleArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_u_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_u_set" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_u_set" "', argument " "2"" of type '" "iDynTree::JointDOFsDoubleArray *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp2);
  if (arg1) (arg1)->u = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_u_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointDOFsDoubleArray *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_u_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_u_get" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  result = (iDynTree::JointDOFsDoubleArray *)& ((arg1)->u);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__JointDOFsDoubleArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_linksVel_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  iDynTree::LinkVelArray *arg2 = (iDynTree::LinkVelArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_linksVel_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linksVel_set" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__LinkVelArray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linksVel_set" "', argument " "2"" of type '" "iDynTree::LinkVelArray *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkVelArray * >(argp2);
  if (arg1) (arg1)->linksVel = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_linksVel_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkVelArray *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_linksVel_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linksVel_get" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  result = (iDynTree::LinkVelArray *)& ((arg1)->linksVel);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkVelArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_linksBiasAcceleration_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  iDynTree::LinkAccArray *arg2 = (iDynTree::LinkAccArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_linksBiasAcceleration_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linksBiasAcceleration_set" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__LinkAccArray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linksBiasAcceleration_set" "', argument " "2"" of type '" "iDynTree::LinkAccArray *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkAccArray * >(argp2);
  if (arg1) (arg1)->linksBiasAcceleration = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_linksBiasAcceleration_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkAccArray *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_linksBiasAcceleration_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linksBiasAcceleration_get" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  result = (iDynTree::LinkAccArray *)& ((arg1)->linksBiasAcceleration);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkAccArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_linksAccelerations_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  iDynTree::LinkAccArray *arg2 = (iDynTree::LinkAccArray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_linksAccelerations_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linksAccelerations_set" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__LinkAccArray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linksAccelerations_set" "', argument " "2"" of type '" "iDynTree::LinkAccArray *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkAccArray * >(argp2);
  if (arg1) (arg1)->linksAccelerations = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_linksAccelerations_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkAccArray *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_linksAccelerations_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linksAccelerations_get" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  result = (iDynTree::LinkAccArray *)& ((arg1)->linksAccelerations);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkAccArray, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_linkABIs_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  iDynTree::LinkArticulatedBodyInertias *arg2 = (iDynTree::LinkArticulatedBodyInertias *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_linkABIs_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linkABIs_set" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linkABIs_set" "', argument " "2"" of type '" "iDynTree::LinkArticulatedBodyInertias *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkArticulatedBodyInertias * >(argp2);
  if (arg1) (arg1)->linkABIs = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_linkABIs_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkArticulatedBodyInertias *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_linkABIs_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linkABIs_get" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  result = (iDynTree::LinkArticulatedBodyInertias *)& ((arg1)->linkABIs);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkArticulatedBodyInertias, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_linksBiasWrench_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  iDynTree::LinkWrenches *arg2 = (iDynTree::LinkWrenches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_linksBiasWrench_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linksBiasWrench_set" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__LinkWrenches, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linksBiasWrench_set" "', argument " "2"" of type '" "iDynTree::LinkWrenches *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkWrenches * >(argp2);
  if (arg1) (arg1)->linksBiasWrench = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithmInternalBuffers_linksBiasWrench_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkWrenches *result = 0 ;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithmInternalBuffers_linksBiasWrench_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithmInternalBuffers_linksBiasWrench_get" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  result = (iDynTree::LinkWrenches *)& ((arg1)->linksBiasWrench);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkWrenches, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ArticulatedBodyAlgorithmInternalBuffers(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg1 = (iDynTree::ArticulatedBodyAlgorithmInternalBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ArticulatedBodyAlgorithmInternalBuffers",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ArticulatedBodyAlgorithmInternalBuffers" "', argument " "1"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ArticulatedBodyAlgorithm(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::FreeFloatingPos *arg3 = 0 ;
  iDynTree::FreeFloatingVel *arg4 = 0 ;
  iDynTree::LinkNetExternalWrenches *arg5 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg6 = 0 ;
  iDynTree::ArticulatedBodyAlgorithmInternalBuffers *arg7 = 0 ;
  iDynTree::FreeFloatingAcc *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ArticulatedBodyAlgorithm",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ArticulatedBodyAlgorithm" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyAlgorithm" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ArticulatedBodyAlgorithm" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyAlgorithm" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__FreeFloatingPos,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ArticulatedBodyAlgorithm" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyAlgorithm" "', argument " "3"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__FreeFloatingVel,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ArticulatedBodyAlgorithm" "', argument " "4"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyAlgorithm" "', argument " "4"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ArticulatedBodyAlgorithm" "', argument " "5"" of type '" "iDynTree::LinkNetExternalWrenches const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyAlgorithm" "', argument " "5"" of type '" "iDynTree::LinkNetExternalWrenches const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkNetExternalWrenches * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ArticulatedBodyAlgorithm" "', argument " "6"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyAlgorithm" "', argument " "6"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ArticulatedBodyAlgorithm" "', argument " "7"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyAlgorithm" "', argument " "7"" of type '" "iDynTree::ArticulatedBodyAlgorithmInternalBuffers &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::ArticulatedBodyAlgorithmInternalBuffers * >(argp7);
  res8 = SWIG_ConvertPtr(argv[7], &argp8, SWIGTYPE_p_iDynTree__FreeFloatingAcc,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ArticulatedBodyAlgorithm" "', argument " "8"" of type '" "iDynTree::FreeFloatingAcc &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ArticulatedBodyAlgorithm" "', argument " "8"" of type '" "iDynTree::FreeFloatingAcc &""'"); 
  }
  arg8 = reinterpret_cast< iDynTree::FreeFloatingAcc * >(argp8);
  result = (bool)iDynTree::ArticulatedBodyAlgorithm((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::FreeFloatingPos const &)*arg3,(iDynTree::FreeFloatingVel const &)*arg4,(iDynTree::LinkWrenches const &)*arg5,(iDynTree::JointDOFsDoubleArray const &)*arg6,*arg7,*arg8);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseDynamicsInertialParametersRegressor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::LinkPositions *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::LinkAccArray *arg5 = 0 ;
  iDynTree::MatrixDynSize *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseDynamicsInertialParametersRegressor",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseDynamicsInertialParametersRegressor" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseDynamicsInertialParametersRegressor" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseDynamicsInertialParametersRegressor" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseDynamicsInertialParametersRegressor" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__LinkPositions,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseDynamicsInertialParametersRegressor" "', argument " "3"" of type '" "iDynTree::LinkPositions const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseDynamicsInertialParametersRegressor" "', argument " "3"" of type '" "iDynTree::LinkPositions const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::LinkPositions * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InverseDynamicsInertialParametersRegressor" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseDynamicsInertialParametersRegressor" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InverseDynamicsInertialParametersRegressor" "', argument " "5"" of type '" "iDynTree::LinkAccArray const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseDynamicsInertialParametersRegressor" "', argument " "5"" of type '" "iDynTree::LinkAccArray const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkAccArray * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "InverseDynamicsInertialParametersRegressor" "', argument " "6"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseDynamicsInertialParametersRegressor" "', argument " "6"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp6);
  result = (bool)iDynTree::InverseDynamicsInertialParametersRegressor((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::LinkPositions const &)*arg3,(iDynTree::LinkVelArray const &)*arg4,(iDynTree::LinkAccArray const &)*arg5,*arg6);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


SWIGINTERN int _wrap_NR_OF_SENSOR_TYPES_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  resv[0] = SWIG_From_int(static_cast< int >(iDynTree::NR_OF_SENSOR_TYPES));
  return 0;
}


int _wrap_isLinkSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("isLinkSensor",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "isLinkSensor" "', argument " "1"" of type '" "iDynTree::SensorType""'");
  } 
  arg1 = static_cast< iDynTree::SensorType >(val1);
  result = (bool)iDynTree::isLinkSensor(arg1);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_isJointSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("isJointSensor",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "isJointSensor" "', argument " "1"" of type '" "iDynTree::SensorType""'");
  } 
  arg1 = static_cast< iDynTree::SensorType >(val1);
  result = (bool)iDynTree::isJointSensor(arg1);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_getSensorTypeSize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("getSensorTypeSize",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getSensorTypeSize" "', argument " "1"" of type '" "iDynTree::SensorType""'");
  } 
  arg1 = static_cast< iDynTree::SensorType >(val1);
  result = iDynTree::getSensorTypeSize(arg1);
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Sensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Sensor *arg1 = (iDynTree::Sensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Sensor",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Sensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sensor" "', argument " "1"" of type '" "iDynTree::Sensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Sensor * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Sensor_getName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Sensor *arg1 = (iDynTree::Sensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Sensor_getName",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Sensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sensor_getName" "', argument " "1"" of type '" "iDynTree::Sensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Sensor * >(argp1);
  result = ((iDynTree::Sensor const *)arg1)->getName();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Sensor_getSensorType(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Sensor *arg1 = (iDynTree::Sensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorType result;
  
  if (!SWIG_check_num_args("Sensor_getSensorType",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Sensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sensor_getSensorType" "', argument " "1"" of type '" "iDynTree::Sensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Sensor * >(argp1);
  result = (iDynTree::SensorType)((iDynTree::Sensor const *)arg1)->getSensorType();
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Sensor_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Sensor *arg1 = (iDynTree::Sensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Sensor_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Sensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sensor_isValid" "', argument " "1"" of type '" "iDynTree::Sensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Sensor * >(argp1);
  result = (bool)((iDynTree::Sensor const *)arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Sensor_setName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Sensor *arg1 = (iDynTree::Sensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Sensor_setName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Sensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sensor_setName" "', argument " "1"" of type '" "iDynTree::Sensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Sensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sensor_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sensor_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setName((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_Sensor_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Sensor *arg1 = (iDynTree::Sensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Sensor *result = 0 ;
  
  if (!SWIG_check_num_args("Sensor_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Sensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sensor_clone" "', argument " "1"" of type '" "iDynTree::Sensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Sensor * >(argp1);
  result = (iDynTree::Sensor *)((iDynTree::Sensor const *)arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Sensor, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Sensor_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Sensor *arg1 = (iDynTree::Sensor *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Sensor_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Sensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sensor_isConsistent" "', argument " "1"" of type '" "iDynTree::Sensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Sensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sensor_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sensor_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::Sensor const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Sensor_updateIndices(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Sensor *arg1 = (iDynTree::Sensor *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Sensor_updateIndices",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Sensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sensor_updateIndices" "', argument " "1"" of type '" "iDynTree::Sensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Sensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sensor_updateIndices" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sensor_updateIndices" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)(arg1)->updateIndices((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_JointSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::JointSensor *arg1 = (iDynTree::JointSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_JointSensor",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__JointSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_JointSensor" "', argument " "1"" of type '" "iDynTree::JointSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::JointSensor * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_JointSensor_getParentJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::JointSensor *arg1 = (iDynTree::JointSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("JointSensor_getParentJoint",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__JointSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JointSensor_getParentJoint" "', argument " "1"" of type '" "iDynTree::JointSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::JointSensor * >(argp1);
  result = ((iDynTree::JointSensor const *)arg1)->getParentJoint();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_JointSensor_getParentJointIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::JointSensor *arg1 = (iDynTree::JointSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("JointSensor_getParentJointIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__JointSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JointSensor_getParentJointIndex" "', argument " "1"" of type '" "iDynTree::JointSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::JointSensor * >(argp1);
  result = ((iDynTree::JointSensor const *)arg1)->getParentJointIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_JointSensor_setParentJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::JointSensor *arg1 = (iDynTree::JointSensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("JointSensor_setParentJoint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__JointSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JointSensor_setParentJoint" "', argument " "1"" of type '" "iDynTree::JointSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::JointSensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JointSensor_setParentJoint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JointSensor_setParentJoint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setParentJoint((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_JointSensor_setParentJointIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::JointSensor *arg1 = (iDynTree::JointSensor *) 0 ;
  iDynTree::JointIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  iDynTree::JointIndex temp2 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("JointSensor_setParentJointIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__JointSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JointSensor_setParentJointIndex" "', argument " "1"" of type '" "iDynTree::JointSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::JointSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "JointSensor_setParentJointIndex" "', argument " "2"" of type '" "iDynTree::JointIndex""'");
  } 
  temp2 = static_cast< iDynTree::JointIndex >(val2);
  arg2 = &temp2;
  result = (bool)(arg1)->setParentJointIndex((iDynTree::JointIndex const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_JointSensor_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::JointSensor *arg1 = (iDynTree::JointSensor *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("JointSensor_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__JointSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "JointSensor_isConsistent" "', argument " "1"" of type '" "iDynTree::JointSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::JointSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "JointSensor_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "JointSensor_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::JointSensor const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_LinkSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkSensor *arg1 = (iDynTree::LinkSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_LinkSensor",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinkSensor" "', argument " "1"" of type '" "iDynTree::LinkSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkSensor * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkSensor_getParentLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkSensor *arg1 = (iDynTree::LinkSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("LinkSensor_getParentLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkSensor_getParentLink" "', argument " "1"" of type '" "iDynTree::LinkSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkSensor * >(argp1);
  result = ((iDynTree::LinkSensor const *)arg1)->getParentLink();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkSensor_getParentLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkSensor *arg1 = (iDynTree::LinkSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("LinkSensor_getParentLinkIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkSensor_getParentLinkIndex" "', argument " "1"" of type '" "iDynTree::LinkSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkSensor * >(argp1);
  result = ((iDynTree::LinkSensor const *)arg1)->getParentLinkIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkSensor_getLinkSensorTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkSensor *arg1 = (iDynTree::LinkSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("LinkSensor_getLinkSensorTransform",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkSensor_getLinkSensorTransform" "', argument " "1"" of type '" "iDynTree::LinkSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkSensor * >(argp1);
  result = ((iDynTree::LinkSensor const *)arg1)->getLinkSensorTransform();
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkSensor_setParentLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkSensor *arg1 = (iDynTree::LinkSensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("LinkSensor_setParentLink",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkSensor_setParentLink" "', argument " "1"" of type '" "iDynTree::LinkSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkSensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkSensor_setParentLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkSensor_setParentLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setParentLink((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_LinkSensor_setParentLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkSensor *arg1 = (iDynTree::LinkSensor *) 0 ;
  iDynTree::LinkIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  iDynTree::LinkIndex temp2 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("LinkSensor_setParentLinkIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkSensor_setParentLinkIndex" "', argument " "1"" of type '" "iDynTree::LinkSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkSensor_setParentLinkIndex" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  temp2 = static_cast< iDynTree::LinkIndex >(val2);
  arg2 = &temp2;
  result = (bool)(arg1)->setParentLinkIndex((iDynTree::LinkIndex const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkSensor_setLinkSensorTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkSensor *arg1 = (iDynTree::LinkSensor *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("LinkSensor_setLinkSensorTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkSensor_setLinkSensorTransform" "', argument " "1"" of type '" "iDynTree::LinkSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkSensor_setLinkSensorTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkSensor_setLinkSensorTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  result = (bool)(arg1)->setLinkSensorTransform((iDynTree::Transform const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkSensor_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkSensor *arg1 = (iDynTree::LinkSensor *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("LinkSensor_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkSensor_isConsistent" "', argument " "1"" of type '" "iDynTree::LinkSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkSensor_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkSensor_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::LinkSensor const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SensorsList__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SensorsList *result = 0 ;
  
  if (!SWIG_check_num_args("new_SensorsList",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::SensorsList *)new iDynTree::SensorsList();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SensorsList, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SensorsList__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorsList *result = 0 ;
  
  if (!SWIG_check_num_args("new_SensorsList",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SensorsList,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SensorsList" "', argument " "1"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SensorsList" "', argument " "1"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  result = (iDynTree::SensorsList *)new iDynTree::SensorsList((iDynTree::SensorsList const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SensorsList, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SensorsList(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_SensorsList__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SensorsList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SensorsList__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_SensorsList'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SensorsList::SensorsList()\n"
    "    iDynTree::SensorsList::SensorsList(iDynTree::SensorsList const &)\n");
  return 1;
}


int _wrap_delete_SensorsList(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SensorsList",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SensorsList" "', argument " "1"" of type '" "iDynTree::SensorsList *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsList_addSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  iDynTree::Sensor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  std::ptrdiff_t result;
  
  if (!SWIG_check_num_args("SensorsList_addSensor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_addSensor" "', argument " "1"" of type '" "iDynTree::SensorsList *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Sensor,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SensorsList_addSensor" "', argument " "2"" of type '" "iDynTree::Sensor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsList_addSensor" "', argument " "2"" of type '" "iDynTree::Sensor const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Sensor * >(argp2);
  result = (arg1)->addSensor((iDynTree::Sensor const &)*arg2);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsList_setSerialization(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsList_setSerialization",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_setSerialization" "', argument " "1"" of type '" "iDynTree::SensorsList *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_setSerialization" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SensorsList_setSerialization" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsList_setSerialization" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->setSerialization((iDynTree::SensorType const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_SensorsList_getSerialization(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsList_getSerialization",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_getSerialization" "', argument " "1"" of type '" "iDynTree::SensorsList *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_getSerialization" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SensorsList_getSerialization" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsList_getSerialization" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp3);
  result = (bool)(arg1)->getSerialization((iDynTree::SensorType const &)*arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsList_getNrOfSensors(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("SensorsList_getNrOfSensors",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_getNrOfSensors" "', argument " "1"" of type '" "iDynTree::SensorsList const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_getNrOfSensors" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  result = ((iDynTree::SensorsList const *)arg1)->getNrOfSensors((iDynTree::SensorType const &)*arg2);
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsList_getSensorIndex__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::ptrdiff_t *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsList_getSensorIndex",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_getSensorIndex" "', argument " "1"" of type '" "iDynTree::SensorsList const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_getSensorIndex" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SensorsList_getSensorIndex" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsList_getSensorIndex" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_std__ptrdiff_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SensorsList_getSensorIndex" "', argument " "4"" of type '" "std::ptrdiff_t &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsList_getSensorIndex" "', argument " "4"" of type '" "std::ptrdiff_t &""'"); 
  }
  arg4 = reinterpret_cast< std::ptrdiff_t * >(argp4);
  result = (bool)((iDynTree::SensorsList const *)arg1)->getSensorIndex((iDynTree::SensorType const &)*arg2,(std::string const &)*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_SensorsList_getSensorIndex__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  std::string *arg3 = 0 ;
  unsigned int *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsList_getSensorIndex",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_getSensorIndex" "', argument " "1"" of type '" "iDynTree::SensorsList const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_getSensorIndex" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SensorsList_getSensorIndex" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsList_getSensorIndex" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SensorsList_getSensorIndex" "', argument " "4"" of type '" "unsigned int &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsList_getSensorIndex" "', argument " "4"" of type '" "unsigned int &""'"); 
  }
  arg4 = reinterpret_cast< unsigned int * >(argp4);
  result = (bool)((iDynTree::SensorsList const *)arg1)->getSensorIndex((iDynTree::SensorType const &)*arg2,(std::string const &)*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_SensorsList_getSensorIndex__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  std::ptrdiff_t result;
  
  if (!SWIG_check_num_args("SensorsList_getSensorIndex",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_getSensorIndex" "', argument " "1"" of type '" "iDynTree::SensorsList const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_getSensorIndex" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SensorsList_getSensorIndex" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsList_getSensorIndex" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = ((iDynTree::SensorsList const *)arg1)->getSensorIndex((iDynTree::SensorType const &)*arg2,(std::string const &)*arg3);
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_SensorsList_getSensorIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SensorsList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SensorsList_getSensorIndex__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SensorsList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_int, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SensorsList_getSensorIndex__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SensorsList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__ptrdiff_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SensorsList_getSensorIndex__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SensorsList_getSensorIndex'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SensorsList::getSensorIndex(iDynTree::SensorType const &,std::string const &,std::ptrdiff_t &) const\n"
    "    iDynTree::SensorsList::getSensorIndex(iDynTree::SensorType const &,std::string const &,unsigned int &) const\n"
    "    iDynTree::SensorsList::getSensorIndex(iDynTree::SensorType const &,std::string const &) const\n");
  return 1;
}


int _wrap_SensorsList_getSizeOfAllSensorsMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("SensorsList_getSizeOfAllSensorsMeasurements",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_getSizeOfAllSensorsMeasurements" "', argument " "1"" of type '" "iDynTree::SensorsList const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  result = ((iDynTree::SensorsList const *)arg1)->getSizeOfAllSensorsMeasurements();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsList_getSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  std::ptrdiff_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::Sensor *result = 0 ;
  
  if (!SWIG_check_num_args("SensorsList_getSensor",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_getSensor" "', argument " "1"" of type '" "iDynTree::SensorsList const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_getSensor" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SensorsList_getSensor" "', argument " "3"" of type '" "std::ptrdiff_t""'");
  } 
  arg3 = static_cast< std::ptrdiff_t >(val3);
  result = (iDynTree::Sensor *)((iDynTree::SensorsList const *)arg1)->getSensor((iDynTree::SensorType const &)*arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Sensor, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsList_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsList_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_isConsistent" "', argument " "1"" of type '" "iDynTree::SensorsList const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SensorsList_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsList_isConsistent" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)((iDynTree::SensorsList const *)arg1)->isConsistent((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsList_removeSensor__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsList_removeSensor",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_removeSensor" "', argument " "1"" of type '" "iDynTree::SensorsList *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_removeSensor" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SensorsList_removeSensor" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsList_removeSensor" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->removeSensor((iDynTree::SensorType const &)*arg2,(std::string const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_SensorsList_removeSensor__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  std::ptrdiff_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsList_removeSensor",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_removeSensor" "', argument " "1"" of type '" "iDynTree::SensorsList *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_removeSensor" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SensorsList_removeSensor" "', argument " "3"" of type '" "std::ptrdiff_t""'");
  } 
  arg3 = static_cast< std::ptrdiff_t >(val3);
  result = (bool)(arg1)->removeSensor((iDynTree::SensorType const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsList_removeSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SensorsList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SensorsList_removeSensor__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SensorsList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SensorsList_removeSensor__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SensorsList_removeSensor'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SensorsList::removeSensor(iDynTree::SensorType const &,std::string const &)\n"
    "    iDynTree::SensorsList::removeSensor(iDynTree::SensorType const &,std::ptrdiff_t const)\n");
  return 1;
}


int _wrap_SensorsList_removeAllSensorsOfType(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsList_removeAllSensorsOfType",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_removeAllSensorsOfType" "', argument " "1"" of type '" "iDynTree::SensorsList *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_removeAllSensorsOfType" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  result = (bool)(arg1)->removeAllSensorsOfType((iDynTree::SensorType const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsList_getSixAxisForceTorqueSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::SixAxisForceTorqueSensor *result = 0 ;
  
  if (!SWIG_check_num_args("SensorsList_getSixAxisForceTorqueSensor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_getSixAxisForceTorqueSensor" "', argument " "1"" of type '" "iDynTree::SensorsList const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_getSixAxisForceTorqueSensor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (iDynTree::SixAxisForceTorqueSensor *)iDynTree_SensorsList_getSixAxisForceTorqueSensor((iDynTree::SensorsList const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsList_getAccelerometerSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::AccelerometerSensor *result = 0 ;
  
  if (!SWIG_check_num_args("SensorsList_getAccelerometerSensor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_getAccelerometerSensor" "', argument " "1"" of type '" "iDynTree::SensorsList const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_getAccelerometerSensor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (iDynTree::AccelerometerSensor *)iDynTree_SensorsList_getAccelerometerSensor((iDynTree::SensorsList const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__AccelerometerSensor, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsList_getGyroscopeSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::GyroscopeSensor *result = 0 ;
  
  if (!SWIG_check_num_args("SensorsList_getGyroscopeSensor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_getGyroscopeSensor" "', argument " "1"" of type '" "iDynTree::SensorsList const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_getGyroscopeSensor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (iDynTree::GyroscopeSensor *)iDynTree_SensorsList_getGyroscopeSensor((iDynTree::SensorsList const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__GyroscopeSensor, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsList_getThreeAxisAngularAccelerometerSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::ThreeAxisAngularAccelerometerSensor *result = 0 ;
  
  if (!SWIG_check_num_args("SensorsList_getThreeAxisAngularAccelerometerSensor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_getThreeAxisAngularAccelerometerSensor" "', argument " "1"" of type '" "iDynTree::SensorsList const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_getThreeAxisAngularAccelerometerSensor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (iDynTree::ThreeAxisAngularAccelerometerSensor *)iDynTree_SensorsList_getThreeAxisAngularAccelerometerSensor((iDynTree::SensorsList const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsList_getThreeAxisForceTorqueContactSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = (iDynTree::SensorsList *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::ThreeAxisForceTorqueContactSensor *result = 0 ;
  
  if (!SWIG_check_num_args("SensorsList_getThreeAxisForceTorqueContactSensor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsList_getThreeAxisForceTorqueContactSensor" "', argument " "1"" of type '" "iDynTree::SensorsList const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsList_getThreeAxisForceTorqueContactSensor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = (iDynTree::ThreeAxisForceTorqueContactSensor *)iDynTree_SensorsList_getThreeAxisForceTorqueContactSensor((iDynTree::SensorsList const *)arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SensorsMeasurements__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SensorsMeasurements *result = 0 ;
  
  if (!SWIG_check_num_args("new_SensorsMeasurements",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::SensorsMeasurements *)new iDynTree::SensorsMeasurements();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SensorsMeasurements, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SensorsMeasurements__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsList *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorsMeasurements *result = 0 ;
  
  if (!SWIG_check_num_args("new_SensorsMeasurements",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SensorsList,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SensorsMeasurements" "', argument " "1"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SensorsMeasurements" "', argument " "1"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsList * >(argp1);
  result = (iDynTree::SensorsMeasurements *)new iDynTree::SensorsMeasurements((iDynTree::SensorsList const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SensorsMeasurements, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SensorsMeasurements__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsMeasurements *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorsMeasurements *result = 0 ;
  
  if (!SWIG_check_num_args("new_SensorsMeasurements",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SensorsMeasurements,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SensorsMeasurements" "', argument " "1"" of type '" "iDynTree::SensorsMeasurements const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SensorsMeasurements" "', argument " "1"" of type '" "iDynTree::SensorsMeasurements const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp1);
  result = (iDynTree::SensorsMeasurements *)new iDynTree::SensorsMeasurements((iDynTree::SensorsMeasurements const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SensorsMeasurements, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SensorsMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_SensorsMeasurements__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SensorsList, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SensorsMeasurements__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SensorsMeasurements, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SensorsMeasurements__SWIG_2(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_SensorsMeasurements'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SensorsMeasurements::SensorsMeasurements()\n"
    "    iDynTree::SensorsMeasurements::SensorsMeasurements(iDynTree::SensorsList const &)\n"
    "    iDynTree::SensorsMeasurements::SensorsMeasurements(iDynTree::SensorsMeasurements const &)\n");
  return 1;
}


int _wrap_delete_SensorsMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsMeasurements *arg1 = (iDynTree::SensorsMeasurements *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SensorsMeasurements",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsMeasurements, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SensorsMeasurements" "', argument " "1"" of type '" "iDynTree::SensorsMeasurements *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsMeasurements_setNrOfSensors(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsMeasurements *arg1 = (iDynTree::SensorsMeasurements *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  std::size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsMeasurements_setNrOfSensors",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsMeasurements, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsMeasurements_setNrOfSensors" "', argument " "1"" of type '" "iDynTree::SensorsMeasurements *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsMeasurements_setNrOfSensors" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SensorsMeasurements_setNrOfSensors" "', argument " "3"" of type '" "std::size_t""'");
  } 
  arg3 = static_cast< std::size_t >(val3);
  result = (bool)(arg1)->setNrOfSensors((iDynTree::SensorType const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsMeasurements_getNrOfSensors(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsMeasurements *arg1 = (iDynTree::SensorsMeasurements *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  mxArray * _out;
  std::size_t result;
  
  if (!SWIG_check_num_args("SensorsMeasurements_getNrOfSensors",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsMeasurements, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsMeasurements_getNrOfSensors" "', argument " "1"" of type '" "iDynTree::SensorsMeasurements const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsMeasurements_getNrOfSensors" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  result = ((iDynTree::SensorsMeasurements const *)arg1)->getNrOfSensors((iDynTree::SensorType const &)*arg2);
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsMeasurements_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsMeasurements *arg1 = (iDynTree::SensorsMeasurements *) 0 ;
  iDynTree::SensorsList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsMeasurements_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsMeasurements, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsMeasurements_resize" "', argument " "1"" of type '" "iDynTree::SensorsMeasurements *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SensorsList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SensorsMeasurements_resize" "', argument " "2"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsMeasurements_resize" "', argument " "2"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SensorsList * >(argp2);
  result = (bool)(arg1)->resize((iDynTree::SensorsList const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsMeasurements_toVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsMeasurements *arg1 = (iDynTree::SensorsMeasurements *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsMeasurements_toVector",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsMeasurements, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsMeasurements_toVector" "', argument " "1"" of type '" "iDynTree::SensorsMeasurements const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SensorsMeasurements_toVector" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsMeasurements_toVector" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  result = (bool)((iDynTree::SensorsMeasurements const *)arg1)->toVector(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsMeasurements_setMeasurement__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsMeasurements *arg1 = (iDynTree::SensorsMeasurements *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  std::ptrdiff_t *arg3 = 0 ;
  iDynTree::Wrench *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  std::ptrdiff_t temp3 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsMeasurements_setMeasurement",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsMeasurements, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsMeasurements_setMeasurement" "', argument " "1"" of type '" "iDynTree::SensorsMeasurements *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsMeasurements_setMeasurement" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SensorsMeasurements_setMeasurement" "', argument " "3"" of type '" "std::ptrdiff_t""'");
  } 
  temp3 = static_cast< std::ptrdiff_t >(val3);
  arg3 = &temp3;
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SensorsMeasurements_setMeasurement" "', argument " "4"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsMeasurements_setMeasurement" "', argument " "4"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Wrench * >(argp4);
  result = (bool)(arg1)->setMeasurement((iDynTree::SensorType const &)*arg2,(std::ptrdiff_t const &)*arg3,(iDynTree::Wrench const &)*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsMeasurements_setMeasurement__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsMeasurements *arg1 = (iDynTree::SensorsMeasurements *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  std::ptrdiff_t *arg3 = 0 ;
  iDynTree::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  std::ptrdiff_t temp3 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsMeasurements_setMeasurement",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsMeasurements, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsMeasurements_setMeasurement" "', argument " "1"" of type '" "iDynTree::SensorsMeasurements *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsMeasurements_setMeasurement" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SensorsMeasurements_setMeasurement" "', argument " "3"" of type '" "std::ptrdiff_t""'");
  } 
  temp3 = static_cast< std::ptrdiff_t >(val3);
  arg3 = &temp3;
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SensorsMeasurements_setMeasurement" "', argument " "4"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsMeasurements_setMeasurement" "', argument " "4"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Vector3 * >(argp4);
  result = (bool)(arg1)->setMeasurement((iDynTree::SensorType const &)*arg2,(std::ptrdiff_t const &)*arg3,(iDynTree::Vector3 const &)*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsMeasurements_setMeasurement(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SensorsMeasurements, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Wrench, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SensorsMeasurements_setMeasurement__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SensorsMeasurements, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SensorsMeasurements_setMeasurement__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SensorsMeasurements_setMeasurement'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SensorsMeasurements::setMeasurement(iDynTree::SensorType const &,std::ptrdiff_t const &,iDynTree::Wrench const &)\n"
    "    iDynTree::SensorsMeasurements::setMeasurement(iDynTree::SensorType const &,std::ptrdiff_t const &,iDynTree::Vector3 const &)\n");
  return 1;
}


int _wrap_SensorsMeasurements_getMeasurement__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsMeasurements *arg1 = (iDynTree::SensorsMeasurements *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  std::ptrdiff_t *arg3 = 0 ;
  iDynTree::Wrench *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  std::ptrdiff_t temp3 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsMeasurements_getMeasurement",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsMeasurements, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsMeasurements_getMeasurement" "', argument " "1"" of type '" "iDynTree::SensorsMeasurements const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsMeasurements_getMeasurement" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SensorsMeasurements_getMeasurement" "', argument " "3"" of type '" "std::ptrdiff_t""'");
  } 
  temp3 = static_cast< std::ptrdiff_t >(val3);
  arg3 = &temp3;
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SensorsMeasurements_getMeasurement" "', argument " "4"" of type '" "iDynTree::Wrench &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsMeasurements_getMeasurement" "', argument " "4"" of type '" "iDynTree::Wrench &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Wrench * >(argp4);
  result = (bool)((iDynTree::SensorsMeasurements const *)arg1)->getMeasurement((iDynTree::SensorType const &)*arg2,(std::ptrdiff_t const &)*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsMeasurements_getMeasurement__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsMeasurements *arg1 = (iDynTree::SensorsMeasurements *) 0 ;
  iDynTree::SensorType *arg2 = 0 ;
  std::ptrdiff_t *arg3 = 0 ;
  iDynTree::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 ;
  iDynTree::SensorType temp2 ;
  std::ptrdiff_t temp3 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SensorsMeasurements_getMeasurement",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsMeasurements, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsMeasurements_getMeasurement" "', argument " "1"" of type '" "iDynTree::SensorsMeasurements const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp1);
  ecode2 = SWIG_AsVal_int (argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SensorsMeasurements_getMeasurement" "', argument " "2"" of type '" "iDynTree::SensorType const &""'");
  } else {
    temp2 = static_cast< iDynTree::SensorType >(val2);
    arg2 = &temp2;
  }
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SensorsMeasurements_getMeasurement" "', argument " "3"" of type '" "std::ptrdiff_t""'");
  } 
  temp3 = static_cast< std::ptrdiff_t >(val3);
  arg3 = &temp3;
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SensorsMeasurements_getMeasurement" "', argument " "4"" of type '" "iDynTree::Vector3 &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SensorsMeasurements_getMeasurement" "', argument " "4"" of type '" "iDynTree::Vector3 &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Vector3 * >(argp4);
  result = (bool)((iDynTree::SensorsMeasurements const *)arg1)->getMeasurement((iDynTree::SensorType const &)*arg2,(std::ptrdiff_t const &)*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SensorsMeasurements_getMeasurement(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SensorsMeasurements, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Wrench, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SensorsMeasurements_getMeasurement__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SensorsMeasurements, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SensorsMeasurements_getMeasurement__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SensorsMeasurements_getMeasurement'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SensorsMeasurements::getMeasurement(iDynTree::SensorType const &,std::ptrdiff_t const &,iDynTree::Wrench &) const\n"
    "    iDynTree::SensorsMeasurements::getMeasurement(iDynTree::SensorType const &,std::ptrdiff_t const &,iDynTree::Vector3 &) const\n");
  return 1;
}


int _wrap_SensorsMeasurements_getSizeOfAllSensorsMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SensorsMeasurements *arg1 = (iDynTree::SensorsMeasurements *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("SensorsMeasurements_getSizeOfAllSensorsMeasurements",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SensorsMeasurements, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SensorsMeasurements_getSizeOfAllSensorsMeasurements" "', argument " "1"" of type '" "iDynTree::SensorsMeasurements const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp1);
  result = ((iDynTree::SensorsMeasurements const *)arg1)->getSizeOfAllSensorsMeasurements();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SixAxisForceTorqueSensor__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SixAxisForceTorqueSensor *result = 0 ;
  
  if (!SWIG_check_num_args("new_SixAxisForceTorqueSensor",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::SixAxisForceTorqueSensor *)new iDynTree::SixAxisForceTorqueSensor();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SixAxisForceTorqueSensor__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SixAxisForceTorqueSensor *result = 0 ;
  
  if (!SWIG_check_num_args("new_SixAxisForceTorqueSensor",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SixAxisForceTorqueSensor" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SixAxisForceTorqueSensor" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  result = (iDynTree::SixAxisForceTorqueSensor *)new iDynTree::SixAxisForceTorqueSensor((iDynTree::SixAxisForceTorqueSensor const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SixAxisForceTorqueSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_SixAxisForceTorqueSensor__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SixAxisForceTorqueSensor__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_SixAxisForceTorqueSensor'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SixAxisForceTorqueSensor::SixAxisForceTorqueSensor()\n"
    "    iDynTree::SixAxisForceTorqueSensor::SixAxisForceTorqueSensor(iDynTree::SixAxisForceTorqueSensor const &)\n");
  return 1;
}


int _wrap_delete_SixAxisForceTorqueSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SixAxisForceTorqueSensor",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SixAxisForceTorqueSensor" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_setName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_setName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_setName" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SixAxisForceTorqueSensor_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setName((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_setFirstLinkSensorTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_setFirstLinkSensorTransform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_setFirstLinkSensorTransform" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SixAxisForceTorqueSensor_setFirstLinkSensorTransform" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SixAxisForceTorqueSensor_setFirstLinkSensorTransform" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_setFirstLinkSensorTransform" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)((iDynTree::SixAxisForceTorqueSensor const *)arg1)->setFirstLinkSensorTransform(arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_setSecondLinkSensorTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_setSecondLinkSensorTransform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_setSecondLinkSensorTransform" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SixAxisForceTorqueSensor_setSecondLinkSensorTransform" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SixAxisForceTorqueSensor_setSecondLinkSensorTransform" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_setSecondLinkSensorTransform" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)((iDynTree::SixAxisForceTorqueSensor const *)arg1)->setSecondLinkSensorTransform(arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_getFirstLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_getFirstLinkIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_getFirstLinkIndex" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  result = ((iDynTree::SixAxisForceTorqueSensor const *)arg1)->getFirstLinkIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_getSecondLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_getSecondLinkIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_getSecondLinkIndex" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  result = ((iDynTree::SixAxisForceTorqueSensor const *)arg1)->getSecondLinkIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_setFirstLinkName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_setFirstLinkName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_setFirstLinkName" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SixAxisForceTorqueSensor_setFirstLinkName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_setFirstLinkName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setFirstLinkName((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_setSecondLinkName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_setSecondLinkName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_setSecondLinkName" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SixAxisForceTorqueSensor_setSecondLinkName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_setSecondLinkName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setSecondLinkName((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_getFirstLinkName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_getFirstLinkName",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_getFirstLinkName" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  result = ((iDynTree::SixAxisForceTorqueSensor const *)arg1)->getFirstLinkName();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_getSecondLinkName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_getSecondLinkName",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_getSecondLinkName" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  result = ((iDynTree::SixAxisForceTorqueSensor const *)arg1)->getSecondLinkName();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_setParentJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_setParentJoint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_setParentJoint" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SixAxisForceTorqueSensor_setParentJoint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_setParentJoint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setParentJoint((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_setParentJointIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  iDynTree::JointIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  iDynTree::JointIndex temp2 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_setParentJointIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_setParentJointIndex" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SixAxisForceTorqueSensor_setParentJointIndex" "', argument " "2"" of type '" "iDynTree::JointIndex""'");
  } 
  temp2 = static_cast< iDynTree::JointIndex >(val2);
  arg2 = &temp2;
  result = (bool)(arg1)->setParentJointIndex((iDynTree::JointIndex const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_setAppliedWrenchLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_setAppliedWrenchLink",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_setAppliedWrenchLink" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SixAxisForceTorqueSensor_setAppliedWrenchLink" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (bool)(arg1)->setAppliedWrenchLink(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_getName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_getName",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_getName" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  result = ((iDynTree::SixAxisForceTorqueSensor const *)arg1)->getName();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_getSensorType(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorType result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_getSensorType",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_getSensorType" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  result = (iDynTree::SensorType)((iDynTree::SixAxisForceTorqueSensor const *)arg1)->getSensorType();
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_getParentJoint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_getParentJoint",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_getParentJoint" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  result = ((iDynTree::SixAxisForceTorqueSensor const *)arg1)->getParentJoint();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_getParentJointIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::JointIndex result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_getParentJointIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_getParentJointIndex" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  result = ((iDynTree::SixAxisForceTorqueSensor const *)arg1)->getParentJointIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_isValid" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  result = (bool)((iDynTree::SixAxisForceTorqueSensor const *)arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Sensor *result = 0 ;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_clone" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  result = (iDynTree::Sensor *)((iDynTree::SixAxisForceTorqueSensor const *)arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Sensor, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_updateIndices(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_updateIndices",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_updateIndices" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SixAxisForceTorqueSensor_updateIndices" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_updateIndices" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)(arg1)->updateIndices((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_getAppliedWrenchLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_getAppliedWrenchLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_getAppliedWrenchLink" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  result = ((iDynTree::SixAxisForceTorqueSensor const *)arg1)->getAppliedWrenchLink();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_isLinkAttachedToSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_isLinkAttachedToSensor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_isLinkAttachedToSensor" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SixAxisForceTorqueSensor_isLinkAttachedToSensor" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (bool)((iDynTree::SixAxisForceTorqueSensor const *)arg1)->isLinkAttachedToSensor(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_getLinkSensorTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_getLinkSensorTransform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_getLinkSensorTransform" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SixAxisForceTorqueSensor_getLinkSensorTransform" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SixAxisForceTorqueSensor_getLinkSensorTransform" "', argument " "3"" of type '" "iDynTree::Transform &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_getLinkSensorTransform" "', argument " "3"" of type '" "iDynTree::Transform &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)((iDynTree::SixAxisForceTorqueSensor const *)arg1)->getLinkSensorTransform(arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_getWrenchAppliedOnLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::Wrench *arg3 = 0 ;
  iDynTree::Wrench *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_getWrenchAppliedOnLink",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_getWrenchAppliedOnLink" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SixAxisForceTorqueSensor_getWrenchAppliedOnLink" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SixAxisForceTorqueSensor_getWrenchAppliedOnLink" "', argument " "3"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_getWrenchAppliedOnLink" "', argument " "3"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Wrench * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SixAxisForceTorqueSensor_getWrenchAppliedOnLink" "', argument " "4"" of type '" "iDynTree::Wrench &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_getWrenchAppliedOnLink" "', argument " "4"" of type '" "iDynTree::Wrench &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Wrench * >(argp4);
  result = (bool)((iDynTree::SixAxisForceTorqueSensor const *)arg1)->getWrenchAppliedOnLink(arg2,(iDynTree::Wrench const &)*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_getWrenchAppliedOnLinkMatrix(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::Matrix6x6 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_getWrenchAppliedOnLinkMatrix",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_getWrenchAppliedOnLinkMatrix" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SixAxisForceTorqueSensor_getWrenchAppliedOnLinkMatrix" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SixAxisForceTorqueSensor_getWrenchAppliedOnLinkMatrix" "', argument " "3"" of type '" "iDynTree::Matrix6x6 &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_getWrenchAppliedOnLinkMatrix" "', argument " "3"" of type '" "iDynTree::Matrix6x6 &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Matrix6x6 * >(argp3);
  result = (bool)((iDynTree::SixAxisForceTorqueSensor const *)arg1)->getWrenchAppliedOnLinkMatrix(arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_getWrenchAppliedOnLinkInverseMatrix(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::Matrix6x6 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_getWrenchAppliedOnLinkInverseMatrix",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_getWrenchAppliedOnLinkInverseMatrix" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SixAxisForceTorqueSensor_getWrenchAppliedOnLinkInverseMatrix" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixFixSizeT_6_6_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SixAxisForceTorqueSensor_getWrenchAppliedOnLinkInverseMatrix" "', argument " "3"" of type '" "iDynTree::Matrix6x6 &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_getWrenchAppliedOnLinkInverseMatrix" "', argument " "3"" of type '" "iDynTree::Matrix6x6 &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Matrix6x6 * >(argp3);
  result = (bool)((iDynTree::SixAxisForceTorqueSensor const *)arg1)->getWrenchAppliedOnLinkInverseMatrix(arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_predictMeasurement(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::LinkInternalWrenches *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::Wrench result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_predictMeasurement",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_predictMeasurement" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SixAxisForceTorqueSensor_predictMeasurement" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_predictMeasurement" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SixAxisForceTorqueSensor_predictMeasurement" "', argument " "3"" of type '" "iDynTree::LinkInternalWrenches const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_predictMeasurement" "', argument " "3"" of type '" "iDynTree::LinkInternalWrenches const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::LinkInternalWrenches * >(argp3);
  result = (arg1)->predictMeasurement((iDynTree::Traversal const &)*arg2,(iDynTree::LinkInternalWrenches const &)*arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Wrench(static_cast< const iDynTree::Wrench& >(result))), SWIGTYPE_p_iDynTree__Wrench, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SixAxisForceTorqueSensor_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SixAxisForceTorqueSensor *arg1 = (iDynTree::SixAxisForceTorqueSensor *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("SixAxisForceTorqueSensor_toString",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SixAxisForceTorqueSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SixAxisForceTorqueSensor_toString" "', argument " "1"" of type '" "iDynTree::SixAxisForceTorqueSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SixAxisForceTorqueSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SixAxisForceTorqueSensor_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SixAxisForceTorqueSensor_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = ((iDynTree::SixAxisForceTorqueSensor const *)arg1)->toString((iDynTree::Model const &)*arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_AccelerometerSensor__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::AccelerometerSensor *result = 0 ;
  
  if (!SWIG_check_num_args("new_AccelerometerSensor",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::AccelerometerSensor *)new iDynTree::AccelerometerSensor();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__AccelerometerSensor, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_AccelerometerSensor__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::AccelerometerSensor *result = 0 ;
  
  if (!SWIG_check_num_args("new_AccelerometerSensor",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__AccelerometerSensor,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_AccelerometerSensor" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_AccelerometerSensor" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  result = (iDynTree::AccelerometerSensor *)new iDynTree::AccelerometerSensor((iDynTree::AccelerometerSensor const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__AccelerometerSensor, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_AccelerometerSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_AccelerometerSensor__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__AccelerometerSensor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AccelerometerSensor__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_AccelerometerSensor'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::AccelerometerSensor::AccelerometerSensor()\n"
    "    iDynTree::AccelerometerSensor::AccelerometerSensor(iDynTree::AccelerometerSensor const &)\n");
  return 1;
}


int _wrap_delete_AccelerometerSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = (iDynTree::AccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_AccelerometerSensor",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AccelerometerSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AccelerometerSensor" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AccelerometerSensor_setName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = (iDynTree::AccelerometerSensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AccelerometerSensor_setName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AccelerometerSensor_setName" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AccelerometerSensor_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AccelerometerSensor_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setName((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_AccelerometerSensor_setLinkSensorTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = (iDynTree::AccelerometerSensor *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AccelerometerSensor_setLinkSensorTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AccelerometerSensor_setLinkSensorTransform" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AccelerometerSensor_setLinkSensorTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AccelerometerSensor_setLinkSensorTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  result = (bool)(arg1)->setLinkSensorTransform((iDynTree::Transform const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AccelerometerSensor_setParentLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = (iDynTree::AccelerometerSensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AccelerometerSensor_setParentLink",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AccelerometerSensor_setParentLink" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AccelerometerSensor_setParentLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AccelerometerSensor_setParentLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setParentLink((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_AccelerometerSensor_setParentLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = (iDynTree::AccelerometerSensor *) 0 ;
  iDynTree::LinkIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  iDynTree::LinkIndex temp2 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AccelerometerSensor_setParentLinkIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AccelerometerSensor_setParentLinkIndex" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AccelerometerSensor_setParentLinkIndex" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  temp2 = static_cast< iDynTree::LinkIndex >(val2);
  arg2 = &temp2;
  result = (bool)(arg1)->setParentLinkIndex((iDynTree::LinkIndex const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AccelerometerSensor_getName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = (iDynTree::AccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("AccelerometerSensor_getName",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AccelerometerSensor_getName" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  result = ((iDynTree::AccelerometerSensor const *)arg1)->getName();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AccelerometerSensor_getSensorType(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = (iDynTree::AccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorType result;
  
  if (!SWIG_check_num_args("AccelerometerSensor_getSensorType",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AccelerometerSensor_getSensorType" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  result = (iDynTree::SensorType)((iDynTree::AccelerometerSensor const *)arg1)->getSensorType();
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AccelerometerSensor_getParentLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = (iDynTree::AccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("AccelerometerSensor_getParentLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AccelerometerSensor_getParentLink" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  result = ((iDynTree::AccelerometerSensor const *)arg1)->getParentLink();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AccelerometerSensor_getParentLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = (iDynTree::AccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("AccelerometerSensor_getParentLinkIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AccelerometerSensor_getParentLinkIndex" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  result = ((iDynTree::AccelerometerSensor const *)arg1)->getParentLinkIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AccelerometerSensor_getLinkSensorTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = (iDynTree::AccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("AccelerometerSensor_getLinkSensorTransform",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AccelerometerSensor_getLinkSensorTransform" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  result = ((iDynTree::AccelerometerSensor const *)arg1)->getLinkSensorTransform();
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AccelerometerSensor_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = (iDynTree::AccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AccelerometerSensor_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AccelerometerSensor_isValid" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  result = (bool)((iDynTree::AccelerometerSensor const *)arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AccelerometerSensor_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = (iDynTree::AccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Sensor *result = 0 ;
  
  if (!SWIG_check_num_args("AccelerometerSensor_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AccelerometerSensor_clone" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  result = (iDynTree::Sensor *)((iDynTree::AccelerometerSensor const *)arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Sensor, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AccelerometerSensor_updateIndices(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = (iDynTree::AccelerometerSensor *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AccelerometerSensor_updateIndices",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AccelerometerSensor_updateIndices" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AccelerometerSensor_updateIndices" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AccelerometerSensor_updateIndices" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)(arg1)->updateIndices((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AccelerometerSensor_predictMeasurement(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AccelerometerSensor *arg1 = (iDynTree::AccelerometerSensor *) 0 ;
  iDynTree::SpatialAcc *arg2 = 0 ;
  iDynTree::Twist *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::LinAcceleration result;
  
  if (!SWIG_check_num_args("AccelerometerSensor_predictMeasurement",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AccelerometerSensor_predictMeasurement" "', argument " "1"" of type '" "iDynTree::AccelerometerSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AccelerometerSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AccelerometerSensor_predictMeasurement" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AccelerometerSensor_predictMeasurement" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialAcc * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AccelerometerSensor_predictMeasurement" "', argument " "3"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AccelerometerSensor_predictMeasurement" "', argument " "3"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Twist * >(argp3);
  result = (arg1)->predictMeasurement((iDynTree::SpatialAcc const &)*arg2,(iDynTree::Twist const &)*arg3);
  _out = SWIG_NewPointerObj((new iDynTree::LinAcceleration(static_cast< const iDynTree::LinAcceleration& >(result))), SWIGTYPE_p_iDynTree__GeomVector3, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_GyroscopeSensor__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::GyroscopeSensor *result = 0 ;
  
  if (!SWIG_check_num_args("new_GyroscopeSensor",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::GyroscopeSensor *)new iDynTree::GyroscopeSensor();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__GyroscopeSensor, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_GyroscopeSensor__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::GyroscopeSensor *result = 0 ;
  
  if (!SWIG_check_num_args("new_GyroscopeSensor",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__GyroscopeSensor,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GyroscopeSensor" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GyroscopeSensor" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  result = (iDynTree::GyroscopeSensor *)new iDynTree::GyroscopeSensor((iDynTree::GyroscopeSensor const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__GyroscopeSensor, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_GyroscopeSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_GyroscopeSensor__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__GyroscopeSensor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GyroscopeSensor__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_GyroscopeSensor'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::GyroscopeSensor::GyroscopeSensor()\n"
    "    iDynTree::GyroscopeSensor::GyroscopeSensor(iDynTree::GyroscopeSensor const &)\n");
  return 1;
}


int _wrap_delete_GyroscopeSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = (iDynTree::GyroscopeSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_GyroscopeSensor",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GyroscopeSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GyroscopeSensor" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GyroscopeSensor_setName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = (iDynTree::GyroscopeSensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("GyroscopeSensor_setName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GyroscopeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GyroscopeSensor_setName" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GyroscopeSensor_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GyroscopeSensor_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setName((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_GyroscopeSensor_setLinkSensorTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = (iDynTree::GyroscopeSensor *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("GyroscopeSensor_setLinkSensorTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GyroscopeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GyroscopeSensor_setLinkSensorTransform" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GyroscopeSensor_setLinkSensorTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GyroscopeSensor_setLinkSensorTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  result = (bool)(arg1)->setLinkSensorTransform((iDynTree::Transform const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GyroscopeSensor_setParentLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = (iDynTree::GyroscopeSensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("GyroscopeSensor_setParentLink",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GyroscopeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GyroscopeSensor_setParentLink" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GyroscopeSensor_setParentLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GyroscopeSensor_setParentLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setParentLink((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_GyroscopeSensor_setParentLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = (iDynTree::GyroscopeSensor *) 0 ;
  iDynTree::LinkIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  iDynTree::LinkIndex temp2 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("GyroscopeSensor_setParentLinkIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GyroscopeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GyroscopeSensor_setParentLinkIndex" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GyroscopeSensor_setParentLinkIndex" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  temp2 = static_cast< iDynTree::LinkIndex >(val2);
  arg2 = &temp2;
  result = (bool)(arg1)->setParentLinkIndex((iDynTree::LinkIndex const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GyroscopeSensor_getName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = (iDynTree::GyroscopeSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("GyroscopeSensor_getName",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GyroscopeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GyroscopeSensor_getName" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  result = ((iDynTree::GyroscopeSensor const *)arg1)->getName();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GyroscopeSensor_getSensorType(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = (iDynTree::GyroscopeSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorType result;
  
  if (!SWIG_check_num_args("GyroscopeSensor_getSensorType",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GyroscopeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GyroscopeSensor_getSensorType" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  result = (iDynTree::SensorType)((iDynTree::GyroscopeSensor const *)arg1)->getSensorType();
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GyroscopeSensor_getParentLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = (iDynTree::GyroscopeSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("GyroscopeSensor_getParentLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GyroscopeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GyroscopeSensor_getParentLink" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  result = ((iDynTree::GyroscopeSensor const *)arg1)->getParentLink();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GyroscopeSensor_getParentLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = (iDynTree::GyroscopeSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("GyroscopeSensor_getParentLinkIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GyroscopeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GyroscopeSensor_getParentLinkIndex" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  result = ((iDynTree::GyroscopeSensor const *)arg1)->getParentLinkIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GyroscopeSensor_getLinkSensorTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = (iDynTree::GyroscopeSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("GyroscopeSensor_getLinkSensorTransform",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GyroscopeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GyroscopeSensor_getLinkSensorTransform" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  result = ((iDynTree::GyroscopeSensor const *)arg1)->getLinkSensorTransform();
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GyroscopeSensor_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = (iDynTree::GyroscopeSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("GyroscopeSensor_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GyroscopeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GyroscopeSensor_isValid" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  result = (bool)((iDynTree::GyroscopeSensor const *)arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GyroscopeSensor_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = (iDynTree::GyroscopeSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Sensor *result = 0 ;
  
  if (!SWIG_check_num_args("GyroscopeSensor_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GyroscopeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GyroscopeSensor_clone" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  result = (iDynTree::Sensor *)((iDynTree::GyroscopeSensor const *)arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Sensor, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GyroscopeSensor_updateIndices(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = (iDynTree::GyroscopeSensor *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("GyroscopeSensor_updateIndices",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GyroscopeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GyroscopeSensor_updateIndices" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GyroscopeSensor_updateIndices" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GyroscopeSensor_updateIndices" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)(arg1)->updateIndices((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_GyroscopeSensor_predictMeasurement(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::GyroscopeSensor *arg1 = (iDynTree::GyroscopeSensor *) 0 ;
  iDynTree::Twist *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::AngVelocity result;
  
  if (!SWIG_check_num_args("GyroscopeSensor_predictMeasurement",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__GyroscopeSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GyroscopeSensor_predictMeasurement" "', argument " "1"" of type '" "iDynTree::GyroscopeSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::GyroscopeSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GyroscopeSensor_predictMeasurement" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GyroscopeSensor_predictMeasurement" "', argument " "2"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Twist * >(argp2);
  result = (arg1)->predictMeasurement((iDynTree::Twist const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::AngVelocity(static_cast< const iDynTree::AngVelocity& >(result))), SWIGTYPE_p_iDynTree__GeomVector3, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ThreeAxisAngularAccelerometerSensor__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ThreeAxisAngularAccelerometerSensor *result = 0 ;
  
  if (!SWIG_check_num_args("new_ThreeAxisAngularAccelerometerSensor",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ThreeAxisAngularAccelerometerSensor *)new iDynTree::ThreeAxisAngularAccelerometerSensor();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ThreeAxisAngularAccelerometerSensor__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ThreeAxisAngularAccelerometerSensor *result = 0 ;
  
  if (!SWIG_check_num_args("new_ThreeAxisAngularAccelerometerSensor",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ThreeAxisAngularAccelerometerSensor" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ThreeAxisAngularAccelerometerSensor" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  result = (iDynTree::ThreeAxisAngularAccelerometerSensor *)new iDynTree::ThreeAxisAngularAccelerometerSensor((iDynTree::ThreeAxisAngularAccelerometerSensor const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ThreeAxisAngularAccelerometerSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_ThreeAxisAngularAccelerometerSensor__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ThreeAxisAngularAccelerometerSensor__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_ThreeAxisAngularAccelerometerSensor'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ThreeAxisAngularAccelerometerSensor::ThreeAxisAngularAccelerometerSensor()\n"
    "    iDynTree::ThreeAxisAngularAccelerometerSensor::ThreeAxisAngularAccelerometerSensor(iDynTree::ThreeAxisAngularAccelerometerSensor const &)\n");
  return 1;
}


int _wrap_delete_ThreeAxisAngularAccelerometerSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = (iDynTree::ThreeAxisAngularAccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ThreeAxisAngularAccelerometerSensor",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ThreeAxisAngularAccelerometerSensor" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisAngularAccelerometerSensor_setName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = (iDynTree::ThreeAxisAngularAccelerometerSensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ThreeAxisAngularAccelerometerSensor_setName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisAngularAccelerometerSensor_setName" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThreeAxisAngularAccelerometerSensor_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreeAxisAngularAccelerometerSensor_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setName((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ThreeAxisAngularAccelerometerSensor_setLinkSensorTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = (iDynTree::ThreeAxisAngularAccelerometerSensor *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ThreeAxisAngularAccelerometerSensor_setLinkSensorTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisAngularAccelerometerSensor_setLinkSensorTransform" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThreeAxisAngularAccelerometerSensor_setLinkSensorTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreeAxisAngularAccelerometerSensor_setLinkSensorTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  result = (bool)(arg1)->setLinkSensorTransform((iDynTree::Transform const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisAngularAccelerometerSensor_setParentLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = (iDynTree::ThreeAxisAngularAccelerometerSensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ThreeAxisAngularAccelerometerSensor_setParentLink",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisAngularAccelerometerSensor_setParentLink" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThreeAxisAngularAccelerometerSensor_setParentLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreeAxisAngularAccelerometerSensor_setParentLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setParentLink((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ThreeAxisAngularAccelerometerSensor_setParentLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = (iDynTree::ThreeAxisAngularAccelerometerSensor *) 0 ;
  iDynTree::LinkIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  iDynTree::LinkIndex temp2 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ThreeAxisAngularAccelerometerSensor_setParentLinkIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisAngularAccelerometerSensor_setParentLinkIndex" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThreeAxisAngularAccelerometerSensor_setParentLinkIndex" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  temp2 = static_cast< iDynTree::LinkIndex >(val2);
  arg2 = &temp2;
  result = (bool)(arg1)->setParentLinkIndex((iDynTree::LinkIndex const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisAngularAccelerometerSensor_getName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = (iDynTree::ThreeAxisAngularAccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("ThreeAxisAngularAccelerometerSensor_getName",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisAngularAccelerometerSensor_getName" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  result = ((iDynTree::ThreeAxisAngularAccelerometerSensor const *)arg1)->getName();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisAngularAccelerometerSensor_getSensorType(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = (iDynTree::ThreeAxisAngularAccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorType result;
  
  if (!SWIG_check_num_args("ThreeAxisAngularAccelerometerSensor_getSensorType",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisAngularAccelerometerSensor_getSensorType" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  result = (iDynTree::SensorType)((iDynTree::ThreeAxisAngularAccelerometerSensor const *)arg1)->getSensorType();
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisAngularAccelerometerSensor_getParentLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = (iDynTree::ThreeAxisAngularAccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("ThreeAxisAngularAccelerometerSensor_getParentLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisAngularAccelerometerSensor_getParentLink" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  result = ((iDynTree::ThreeAxisAngularAccelerometerSensor const *)arg1)->getParentLink();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisAngularAccelerometerSensor_getParentLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = (iDynTree::ThreeAxisAngularAccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("ThreeAxisAngularAccelerometerSensor_getParentLinkIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisAngularAccelerometerSensor_getParentLinkIndex" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  result = ((iDynTree::ThreeAxisAngularAccelerometerSensor const *)arg1)->getParentLinkIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisAngularAccelerometerSensor_getLinkSensorTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = (iDynTree::ThreeAxisAngularAccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("ThreeAxisAngularAccelerometerSensor_getLinkSensorTransform",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisAngularAccelerometerSensor_getLinkSensorTransform" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  result = ((iDynTree::ThreeAxisAngularAccelerometerSensor const *)arg1)->getLinkSensorTransform();
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisAngularAccelerometerSensor_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = (iDynTree::ThreeAxisAngularAccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ThreeAxisAngularAccelerometerSensor_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisAngularAccelerometerSensor_isValid" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  result = (bool)((iDynTree::ThreeAxisAngularAccelerometerSensor const *)arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisAngularAccelerometerSensor_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = (iDynTree::ThreeAxisAngularAccelerometerSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Sensor *result = 0 ;
  
  if (!SWIG_check_num_args("ThreeAxisAngularAccelerometerSensor_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisAngularAccelerometerSensor_clone" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  result = (iDynTree::Sensor *)((iDynTree::ThreeAxisAngularAccelerometerSensor const *)arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Sensor, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisAngularAccelerometerSensor_updateIndices(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = (iDynTree::ThreeAxisAngularAccelerometerSensor *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ThreeAxisAngularAccelerometerSensor_updateIndices",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisAngularAccelerometerSensor_updateIndices" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThreeAxisAngularAccelerometerSensor_updateIndices" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreeAxisAngularAccelerometerSensor_updateIndices" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)(arg1)->updateIndices((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisAngularAccelerometerSensor_predictMeasurement(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisAngularAccelerometerSensor *arg1 = (iDynTree::ThreeAxisAngularAccelerometerSensor *) 0 ;
  iDynTree::SpatialAcc *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Vector3 result;
  
  if (!SWIG_check_num_args("ThreeAxisAngularAccelerometerSensor_predictMeasurement",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisAngularAccelerometerSensor_predictMeasurement" "', argument " "1"" of type '" "iDynTree::ThreeAxisAngularAccelerometerSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisAngularAccelerometerSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpatialAcc,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThreeAxisAngularAccelerometerSensor_predictMeasurement" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreeAxisAngularAccelerometerSensor_predictMeasurement" "', argument " "2"" of type '" "iDynTree::SpatialAcc const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SpatialAcc * >(argp2);
  result = (arg1)->predictMeasurement((iDynTree::SpatialAcc const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Vector3(static_cast< const iDynTree::Vector3& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ThreeAxisForceTorqueContactSensor__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ThreeAxisForceTorqueContactSensor *result = 0 ;
  
  if (!SWIG_check_num_args("new_ThreeAxisForceTorqueContactSensor",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ThreeAxisForceTorqueContactSensor *)new iDynTree::ThreeAxisForceTorqueContactSensor();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ThreeAxisForceTorqueContactSensor__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ThreeAxisForceTorqueContactSensor *result = 0 ;
  
  if (!SWIG_check_num_args("new_ThreeAxisForceTorqueContactSensor",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ThreeAxisForceTorqueContactSensor" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ThreeAxisForceTorqueContactSensor" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  result = (iDynTree::ThreeAxisForceTorqueContactSensor *)new iDynTree::ThreeAxisForceTorqueContactSensor((iDynTree::ThreeAxisForceTorqueContactSensor const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ThreeAxisForceTorqueContactSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_ThreeAxisForceTorqueContactSensor__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ThreeAxisForceTorqueContactSensor__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_ThreeAxisForceTorqueContactSensor'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ThreeAxisForceTorqueContactSensor::ThreeAxisForceTorqueContactSensor()\n"
    "    iDynTree::ThreeAxisForceTorqueContactSensor::ThreeAxisForceTorqueContactSensor(iDynTree::ThreeAxisForceTorqueContactSensor const &)\n");
  return 1;
}


int _wrap_delete_ThreeAxisForceTorqueContactSensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ThreeAxisForceTorqueContactSensor",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ThreeAxisForceTorqueContactSensor" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_setName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_setName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_setName" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThreeAxisForceTorqueContactSensor_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreeAxisForceTorqueContactSensor_setName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setName((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_setLinkSensorTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_setLinkSensorTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_setLinkSensorTransform" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThreeAxisForceTorqueContactSensor_setLinkSensorTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreeAxisForceTorqueContactSensor_setLinkSensorTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  result = (bool)(arg1)->setLinkSensorTransform((iDynTree::Transform const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_setParentLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_setParentLink",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_setParentLink" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThreeAxisForceTorqueContactSensor_setParentLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreeAxisForceTorqueContactSensor_setParentLink" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setParentLink((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_setParentLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  iDynTree::LinkIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  iDynTree::LinkIndex temp2 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_setParentLinkIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_setParentLinkIndex" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThreeAxisForceTorqueContactSensor_setParentLinkIndex" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  temp2 = static_cast< iDynTree::LinkIndex >(val2);
  arg2 = &temp2;
  result = (bool)(arg1)->setParentLinkIndex((iDynTree::LinkIndex const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_getName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_getName",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_getName" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  result = ((iDynTree::ThreeAxisForceTorqueContactSensor const *)arg1)->getName();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_getSensorType(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorType result;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_getSensorType",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_getSensorType" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  result = (iDynTree::SensorType)((iDynTree::ThreeAxisForceTorqueContactSensor const *)arg1)->getSensorType();
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_getParentLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_getParentLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_getParentLink" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  result = ((iDynTree::ThreeAxisForceTorqueContactSensor const *)arg1)->getParentLink();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_getParentLinkIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkIndex result;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_getParentLinkIndex",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_getParentLinkIndex" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  result = ((iDynTree::ThreeAxisForceTorqueContactSensor const *)arg1)->getParentLinkIndex();
  _out = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_getLinkSensorTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_getLinkSensorTransform",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_getLinkSensorTransform" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  result = ((iDynTree::ThreeAxisForceTorqueContactSensor const *)arg1)->getLinkSensorTransform();
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_isValid" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  result = (bool)((iDynTree::ThreeAxisForceTorqueContactSensor const *)arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_clone(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Sensor *result = 0 ;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_clone",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_clone" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  result = (iDynTree::Sensor *)((iDynTree::ThreeAxisForceTorqueContactSensor const *)arg1)->clone();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Sensor, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_updateIndices(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_updateIndices",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_updateIndices" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThreeAxisForceTorqueContactSensor_updateIndices" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreeAxisForceTorqueContactSensor_updateIndices" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)(arg1)->updateIndices((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_setLoadCellLocations(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  std::vector< iDynTree::Position,std::allocator< iDynTree::Position > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_setLoadCellLocations",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_setLoadCellLocations" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__vectorT_iDynTree__Position_std__allocatorT_iDynTree__Position_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThreeAxisForceTorqueContactSensor_setLoadCellLocations" "', argument " "2"" of type '" "std::vector< iDynTree::Position,std::allocator< iDynTree::Position > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreeAxisForceTorqueContactSensor_setLoadCellLocations" "', argument " "2"" of type '" "std::vector< iDynTree::Position,std::allocator< iDynTree::Position > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::Position,std::allocator< iDynTree::Position > > * >(argp2);
  (arg1)->setLoadCellLocations(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_getLoadCellLocations(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< std::vector< iDynTree::Position,std::allocator< iDynTree::Position > > > result;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_getLoadCellLocations",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_getLoadCellLocations" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  result = ((iDynTree::ThreeAxisForceTorqueContactSensor const *)arg1)->getLoadCellLocations();
  _out = SWIG_NewPointerObj((new std::vector< iDynTree::Position,std::allocator< iDynTree::Position > >(static_cast< const std::vector< iDynTree::Position,std::allocator< iDynTree::Position > >& >(result))), SWIGTYPE_p_std__vectorT_iDynTree__Position_std__allocatorT_iDynTree__Position_t_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_computeThreeAxisForceTorqueFromLoadCellMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Vector3 result;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_computeThreeAxisForceTorqueFromLoadCellMeasurements",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_computeThreeAxisForceTorqueFromLoadCellMeasurements" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThreeAxisForceTorqueContactSensor_computeThreeAxisForceTorqueFromLoadCellMeasurements" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreeAxisForceTorqueContactSensor_computeThreeAxisForceTorqueFromLoadCellMeasurements" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  result = ((iDynTree::ThreeAxisForceTorqueContactSensor const *)arg1)->computeThreeAxisForceTorqueFromLoadCellMeasurements(*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Vector3(static_cast< const iDynTree::Vector3& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ThreeAxisForceTorqueContactSensor_computeCenterOfPressureFromLoadCellMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ThreeAxisForceTorqueContactSensor *arg1 = (iDynTree::ThreeAxisForceTorqueContactSensor *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Position result;
  
  if (!SWIG_check_num_args("ThreeAxisForceTorqueContactSensor_computeCenterOfPressureFromLoadCellMeasurements",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ThreeAxisForceTorqueContactSensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThreeAxisForceTorqueContactSensor_computeCenterOfPressureFromLoadCellMeasurements" "', argument " "1"" of type '" "iDynTree::ThreeAxisForceTorqueContactSensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ThreeAxisForceTorqueContactSensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ThreeAxisForceTorqueContactSensor_computeCenterOfPressureFromLoadCellMeasurements" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ThreeAxisForceTorqueContactSensor_computeCenterOfPressureFromLoadCellMeasurements" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  result = ((iDynTree::ThreeAxisForceTorqueContactSensor const *)arg1)->computeCenterOfPressureFromLoadCellMeasurements(*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_predictSensorsMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::SensorsList *arg2 = 0 ;
  iDynTree::Traversal *arg3 = 0 ;
  iDynTree::FreeFloatingPos *arg4 = 0 ;
  iDynTree::FreeFloatingVel *arg5 = 0 ;
  iDynTree::FreeFloatingAcc *arg6 = 0 ;
  iDynTree::LinAcceleration *arg7 = 0 ;
  iDynTree::LinkNetExternalWrenches *arg8 = 0 ;
  iDynTree::FreeFloatingAcc *arg9 = 0 ;
  iDynTree::LinkPositions *arg10 = 0 ;
  iDynTree::LinkVelArray *arg11 = 0 ;
  iDynTree::LinkAccArray *arg12 = 0 ;
  iDynTree::LinkInternalWrenches *arg13 = 0 ;
  iDynTree::FreeFloatingGeneralizedTorques *arg14 = 0 ;
  iDynTree::SensorsMeasurements *arg15 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("predictSensorsMeasurements",argc,15,15,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "predictSensorsMeasurements" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SensorsList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "predictSensorsMeasurements" "', argument " "2"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "2"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SensorsList * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "predictSensorsMeasurements" "', argument " "3"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "3"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Traversal * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__FreeFloatingPos,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "predictSensorsMeasurements" "', argument " "4"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "4"" of type '" "iDynTree::FreeFloatingPos const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::FreeFloatingPos * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__FreeFloatingVel,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "predictSensorsMeasurements" "', argument " "5"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "5"" of type '" "iDynTree::FreeFloatingVel const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::FreeFloatingVel * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__FreeFloatingAcc,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "predictSensorsMeasurements" "', argument " "6"" of type '" "iDynTree::FreeFloatingAcc const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "6"" of type '" "iDynTree::FreeFloatingAcc const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::FreeFloatingAcc * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__GeomVector3,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "predictSensorsMeasurements" "', argument " "7"" of type '" "iDynTree::LinAcceleration const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "7"" of type '" "iDynTree::LinAcceleration const &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::LinAcceleration * >(argp7);
  res8 = SWIG_ConvertPtr(argv[7], &argp8, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "predictSensorsMeasurements" "', argument " "8"" of type '" "iDynTree::LinkNetExternalWrenches const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "8"" of type '" "iDynTree::LinkNetExternalWrenches const &""'"); 
  }
  arg8 = reinterpret_cast< iDynTree::LinkNetExternalWrenches * >(argp8);
  res9 = SWIG_ConvertPtr(argv[8], &argp9, SWIGTYPE_p_iDynTree__FreeFloatingAcc,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "predictSensorsMeasurements" "', argument " "9"" of type '" "iDynTree::FreeFloatingAcc &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "9"" of type '" "iDynTree::FreeFloatingAcc &""'"); 
  }
  arg9 = reinterpret_cast< iDynTree::FreeFloatingAcc * >(argp9);
  res10 = SWIG_ConvertPtr(argv[9], &argp10, SWIGTYPE_p_iDynTree__LinkPositions,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "predictSensorsMeasurements" "', argument " "10"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "10"" of type '" "iDynTree::LinkPositions &""'"); 
  }
  arg10 = reinterpret_cast< iDynTree::LinkPositions * >(argp10);
  res11 = SWIG_ConvertPtr(argv[10], &argp11, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "predictSensorsMeasurements" "', argument " "11"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp11) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "11"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg11 = reinterpret_cast< iDynTree::LinkVelArray * >(argp11);
  res12 = SWIG_ConvertPtr(argv[11], &argp12, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "predictSensorsMeasurements" "', argument " "12"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp12) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "12"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg12 = reinterpret_cast< iDynTree::LinkAccArray * >(argp12);
  res13 = SWIG_ConvertPtr(argv[12], &argp13, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "predictSensorsMeasurements" "', argument " "13"" of type '" "iDynTree::LinkInternalWrenches &""'"); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "13"" of type '" "iDynTree::LinkInternalWrenches &""'"); 
  }
  arg13 = reinterpret_cast< iDynTree::LinkInternalWrenches * >(argp13);
  res14 = SWIG_ConvertPtr(argv[13], &argp14, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "predictSensorsMeasurements" "', argument " "14"" of type '" "iDynTree::FreeFloatingGeneralizedTorques &""'"); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "14"" of type '" "iDynTree::FreeFloatingGeneralizedTorques &""'"); 
  }
  arg14 = reinterpret_cast< iDynTree::FreeFloatingGeneralizedTorques * >(argp14);
  res15 = SWIG_ConvertPtr(argv[14], &argp15, SWIGTYPE_p_iDynTree__SensorsMeasurements,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "predictSensorsMeasurements" "', argument " "15"" of type '" "iDynTree::SensorsMeasurements &""'"); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurements" "', argument " "15"" of type '" "iDynTree::SensorsMeasurements &""'"); 
  }
  arg15 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp15);
  result = (bool)iDynTree::predictSensorsMeasurements((iDynTree::Model const &)*arg1,(iDynTree::SensorsList const &)*arg2,(iDynTree::Traversal const &)*arg3,(iDynTree::FreeFloatingPos const &)*arg4,(iDynTree::FreeFloatingVel const &)*arg5,(iDynTree::FreeFloatingAcc const &)*arg6,(iDynTree::GeomVector3 const &)*arg7,(iDynTree::LinkWrenches const &)*arg8,*arg9,*arg10,*arg11,*arg12,*arg13,*arg14,*arg15);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_predictSensorsMeasurementsFromRawBuffers(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::SensorsList *arg2 = 0 ;
  iDynTree::Traversal *arg3 = 0 ;
  iDynTree::LinkVelArray *arg4 = 0 ;
  iDynTree::LinkAccArray *arg5 = 0 ;
  iDynTree::LinkInternalWrenches *arg6 = 0 ;
  iDynTree::SensorsMeasurements *arg7 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("predictSensorsMeasurementsFromRawBuffers",argc,7,7,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "predictSensorsMeasurementsFromRawBuffers" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurementsFromRawBuffers" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SensorsList,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "predictSensorsMeasurementsFromRawBuffers" "', argument " "2"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurementsFromRawBuffers" "', argument " "2"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SensorsList * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "predictSensorsMeasurementsFromRawBuffers" "', argument " "3"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurementsFromRawBuffers" "', argument " "3"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Traversal * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "predictSensorsMeasurementsFromRawBuffers" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurementsFromRawBuffers" "', argument " "4"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkVelArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "predictSensorsMeasurementsFromRawBuffers" "', argument " "5"" of type '" "iDynTree::LinkAccArray const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurementsFromRawBuffers" "', argument " "5"" of type '" "iDynTree::LinkAccArray const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkAccArray * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "predictSensorsMeasurementsFromRawBuffers" "', argument " "6"" of type '" "iDynTree::LinkInternalWrenches const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurementsFromRawBuffers" "', argument " "6"" of type '" "iDynTree::LinkInternalWrenches const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkInternalWrenches * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__SensorsMeasurements,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "predictSensorsMeasurementsFromRawBuffers" "', argument " "7"" of type '" "iDynTree::SensorsMeasurements &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictSensorsMeasurementsFromRawBuffers" "', argument " "7"" of type '" "iDynTree::SensorsMeasurements &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp7);
  result = (bool)iDynTree::predictSensorsMeasurementsFromRawBuffers((iDynTree::Model const &)*arg1,(iDynTree::SensorsList const &)*arg2,(iDynTree::Traversal const &)*arg3,(iDynTree::LinkVelArray const &)*arg4,(iDynTree::LinkAccArray const &)*arg5,(iDynTree::LinkWrenches const &)*arg6,*arg7);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_dofsListFromURDF(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::string *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("dofsListFromURDF",argc,2,2,0)) {
    SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dofsListFromURDF" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dofsListFromURDF" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dofsListFromURDF" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dofsListFromURDF" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  result = (bool)iDynTree::dofsListFromURDF((std::string const &)*arg1,*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 0;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 1;
}


int _wrap_dofsListFromURDFString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::string *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("dofsListFromURDFString",argc,2,2,0)) {
    SWIG_fail;
  }
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dofsListFromURDFString" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dofsListFromURDFString" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dofsListFromURDFString" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dofsListFromURDFString" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  result = (bool)iDynTree::dofsListFromURDFString((std::string const &)*arg1,*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 0;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 1;
}


int _wrap_ModelParserOptions_addSensorFramesAsAdditionalFrames_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelParserOptions *arg1 = (iDynTree::ModelParserOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ModelParserOptions_addSensorFramesAsAdditionalFrames_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelParserOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelParserOptions_addSensorFramesAsAdditionalFrames_set" "', argument " "1"" of type '" "iDynTree::ModelParserOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelParserOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ModelParserOptions_addSensorFramesAsAdditionalFrames_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->addSensorFramesAsAdditionalFrames = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelParserOptions_addSensorFramesAsAdditionalFrames_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelParserOptions *arg1 = (iDynTree::ModelParserOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelParserOptions_addSensorFramesAsAdditionalFrames_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelParserOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelParserOptions_addSensorFramesAsAdditionalFrames_get" "', argument " "1"" of type '" "iDynTree::ModelParserOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelParserOptions * >(argp1);
  result = (bool) ((arg1)->addSensorFramesAsAdditionalFrames);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelParserOptions_originalFilename_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelParserOptions *arg1 = (iDynTree::ModelParserOptions *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ModelParserOptions_originalFilename_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelParserOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelParserOptions_originalFilename_set" "', argument " "1"" of type '" "iDynTree::ModelParserOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelParserOptions * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelParserOptions_originalFilename_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelParserOptions_originalFilename_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->originalFilename = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ModelParserOptions_originalFilename_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelParserOptions *arg1 = (iDynTree::ModelParserOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string *result = 0 ;
  
  if (!SWIG_check_num_args("ModelParserOptions_originalFilename_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelParserOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelParserOptions_originalFilename_get" "', argument " "1"" of type '" "iDynTree::ModelParserOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelParserOptions * >(argp1);
  result = (std::string *) & ((arg1)->originalFilename);
  _out = SWIG_From_std_string(static_cast< std::string >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ModelParserOptions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ModelParserOptions *result = 0 ;
  
  if (!SWIG_check_num_args("new_ModelParserOptions",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ModelParserOptions *)new iDynTree::ModelParserOptions();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ModelParserOptions, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ModelParserOptions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelParserOptions *arg1 = (iDynTree::ModelParserOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ModelParserOptions",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelParserOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModelParserOptions" "', argument " "1"" of type '" "iDynTree::ModelParserOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelParserOptions * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ModelLoader(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ModelLoader *result = 0 ;
  
  if (!SWIG_check_num_args("new_ModelLoader",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ModelLoader *)new iDynTree::ModelLoader();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ModelLoader, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ModelLoader(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ModelLoader",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModelLoader" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelLoader_parsingOptions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ModelParserOptions *result = 0 ;
  
  if (!SWIG_check_num_args("ModelLoader_parsingOptions",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_parsingOptions" "', argument " "1"" of type '" "iDynTree::ModelLoader const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  result = (iDynTree::ModelParserOptions *) &((iDynTree::ModelLoader const *)arg1)->parsingOptions();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ModelParserOptions, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelLoader_setParsingOptions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  iDynTree::ModelParserOptions *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ModelLoader_setParsingOptions",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_setParsingOptions" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ModelParserOptions,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelLoader_setParsingOptions" "', argument " "2"" of type '" "iDynTree::ModelParserOptions const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_setParsingOptions" "', argument " "2"" of type '" "iDynTree::ModelParserOptions const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ModelParserOptions * >(argp2);
  (arg1)->setParsingOptions((iDynTree::ModelParserOptions const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelLoader_loadModelFromString__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelLoader_loadModelFromString",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_loadModelFromString" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelLoader_loadModelFromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_loadModelFromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelLoader_loadModelFromString" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_loadModelFromString" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->loadModelFromString((std::string const &)*arg2,(std::string const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_ModelLoader_loadModelFromString__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelLoader_loadModelFromString",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_loadModelFromString" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelLoader_loadModelFromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_loadModelFromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->loadModelFromString((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ModelLoader_loadModelFromString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelLoader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ModelLoader_loadModelFromString__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelLoader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModelLoader_loadModelFromString__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ModelLoader_loadModelFromString'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelLoader::loadModelFromString(std::string const &,std::string const &)\n"
    "    iDynTree::ModelLoader::loadModelFromString(std::string const &)\n");
  return 1;
}


int _wrap_ModelLoader_loadModelFromFile__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelLoader_loadModelFromFile",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_loadModelFromFile" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelLoader_loadModelFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_loadModelFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelLoader_loadModelFromFile" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_loadModelFromFile" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->loadModelFromFile((std::string const &)*arg2,(std::string const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_ModelLoader_loadModelFromFile__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelLoader_loadModelFromFile",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_loadModelFromFile" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelLoader_loadModelFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_loadModelFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->loadModelFromFile((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ModelLoader_loadModelFromFile(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelLoader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ModelLoader_loadModelFromFile__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelLoader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModelLoader_loadModelFromFile__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ModelLoader_loadModelFromFile'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelLoader::loadModelFromFile(std::string const &,std::string const &)\n"
    "    iDynTree::ModelLoader::loadModelFromFile(std::string const &)\n");
  return 1;
}


int _wrap_ModelLoader_loadReducedModelFromFullModel__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelLoader_loadReducedModelFromFullModel",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_loadReducedModelFromFullModel" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelLoader_loadReducedModelFromFullModel" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_loadReducedModelFromFullModel" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelLoader_loadReducedModelFromFullModel" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_loadReducedModelFromFullModel" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelLoader_loadReducedModelFromFullModel" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->loadReducedModelFromFullModel((iDynTree::Model const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_ModelLoader_loadReducedModelFromFullModel__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelLoader_loadReducedModelFromFullModel",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_loadReducedModelFromFullModel" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelLoader_loadReducedModelFromFullModel" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_loadReducedModelFromFullModel" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelLoader_loadReducedModelFromFullModel" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_loadReducedModelFromFullModel" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->loadReducedModelFromFullModel((iDynTree::Model const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_ModelLoader_loadReducedModelFromFullModel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelLoader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModelLoader_loadReducedModelFromFullModel__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelLoader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ModelLoader_loadReducedModelFromFullModel__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ModelLoader_loadReducedModelFromFullModel'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelLoader::loadReducedModelFromFullModel(iDynTree::Model const &,std::vector< std::string,std::allocator< std::string > > const &,std::string const)\n"
    "    iDynTree::ModelLoader::loadReducedModelFromFullModel(iDynTree::Model const &,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 1;
}


int _wrap_ModelLoader_loadReducedModelFromString__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  std::string arg2 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelLoader_loadReducedModelFromString",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_loadReducedModelFromString" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelLoader_loadReducedModelFromString" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelLoader_loadReducedModelFromString" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_loadReducedModelFromString" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelLoader_loadReducedModelFromString" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->loadReducedModelFromString(arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_ModelLoader_loadReducedModelFromString__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  std::string arg2 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelLoader_loadReducedModelFromString",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_loadReducedModelFromString" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelLoader_loadReducedModelFromString" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelLoader_loadReducedModelFromString" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_loadReducedModelFromString" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->loadReducedModelFromString(arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_ModelLoader_loadReducedModelFromString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelLoader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModelLoader_loadReducedModelFromString__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelLoader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ModelLoader_loadReducedModelFromString__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ModelLoader_loadReducedModelFromString'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelLoader::loadReducedModelFromString(std::string const,std::vector< std::string,std::allocator< std::string > > const &,std::string const)\n"
    "    iDynTree::ModelLoader::loadReducedModelFromString(std::string const,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 1;
}


int _wrap_ModelLoader_loadReducedModelFromFile__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  std::string arg2 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelLoader_loadReducedModelFromFile",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_loadReducedModelFromFile" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelLoader_loadReducedModelFromFile" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelLoader_loadReducedModelFromFile" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_loadReducedModelFromFile" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelLoader_loadReducedModelFromFile" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->loadReducedModelFromFile(arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_ModelLoader_loadReducedModelFromFile__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  std::string arg2 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelLoader_loadReducedModelFromFile",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_loadReducedModelFromFile" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelLoader_loadReducedModelFromFile" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelLoader_loadReducedModelFromFile" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelLoader_loadReducedModelFromFile" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->loadReducedModelFromFile(arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_ModelLoader_loadReducedModelFromFile(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelLoader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModelLoader_loadReducedModelFromFile__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelLoader, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ModelLoader_loadReducedModelFromFile__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ModelLoader_loadReducedModelFromFile'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelLoader::loadReducedModelFromFile(std::string const,std::vector< std::string,std::allocator< std::string > > const &,std::string const)\n"
    "    iDynTree::ModelLoader::loadReducedModelFromFile(std::string const,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 1;
}


int _wrap_ModelLoader_model(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Model *result = 0 ;
  
  if (!SWIG_check_num_args("ModelLoader_model",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_model" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  result = (iDynTree::Model *) &(arg1)->model();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelLoader_sensors(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorsList *result = 0 ;
  
  if (!SWIG_check_num_args("ModelLoader_sensors",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_sensors" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  result = (iDynTree::SensorsList *) &(arg1)->sensors();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelLoader_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelLoader *arg1 = (iDynTree::ModelLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelLoader_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelLoader_isValid" "', argument " "1"" of type '" "iDynTree::ModelLoader *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelLoader * >(argp1);
  result = (bool)(arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporterOptions_baseLink_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporterOptions *arg1 = (iDynTree::ModelExporterOptions *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ModelExporterOptions_baseLink_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporterOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporterOptions_baseLink_set" "', argument " "1"" of type '" "iDynTree::ModelExporterOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporterOptions * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelExporterOptions_baseLink_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelExporterOptions_baseLink_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->baseLink = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ModelExporterOptions_baseLink_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporterOptions *arg1 = (iDynTree::ModelExporterOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string *result = 0 ;
  
  if (!SWIG_check_num_args("ModelExporterOptions_baseLink_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporterOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporterOptions_baseLink_get" "', argument " "1"" of type '" "iDynTree::ModelExporterOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporterOptions * >(argp1);
  result = (std::string *) & ((arg1)->baseLink);
  _out = SWIG_From_std_string(static_cast< std::string >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporterOptions_exportFirstBaseLinkAdditionalFrameAsFakeURDFBase_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporterOptions *arg1 = (iDynTree::ModelExporterOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ModelExporterOptions_exportFirstBaseLinkAdditionalFrameAsFakeURDFBase_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporterOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporterOptions_exportFirstBaseLinkAdditionalFrameAsFakeURDFBase_set" "', argument " "1"" of type '" "iDynTree::ModelExporterOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporterOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ModelExporterOptions_exportFirstBaseLinkAdditionalFrameAsFakeURDFBase_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->exportFirstBaseLinkAdditionalFrameAsFakeURDFBase = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporterOptions_exportFirstBaseLinkAdditionalFrameAsFakeURDFBase_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporterOptions *arg1 = (iDynTree::ModelExporterOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelExporterOptions_exportFirstBaseLinkAdditionalFrameAsFakeURDFBase_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporterOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporterOptions_exportFirstBaseLinkAdditionalFrameAsFakeURDFBase_get" "', argument " "1"" of type '" "iDynTree::ModelExporterOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporterOptions * >(argp1);
  result = (bool) ((arg1)->exportFirstBaseLinkAdditionalFrameAsFakeURDFBase);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporterOptions_robotExportedName_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporterOptions *arg1 = (iDynTree::ModelExporterOptions *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ModelExporterOptions_robotExportedName_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporterOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporterOptions_robotExportedName_set" "', argument " "1"" of type '" "iDynTree::ModelExporterOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporterOptions * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelExporterOptions_robotExportedName_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelExporterOptions_robotExportedName_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->robotExportedName = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ModelExporterOptions_robotExportedName_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporterOptions *arg1 = (iDynTree::ModelExporterOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string *result = 0 ;
  
  if (!SWIG_check_num_args("ModelExporterOptions_robotExportedName_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporterOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporterOptions_robotExportedName_get" "', argument " "1"" of type '" "iDynTree::ModelExporterOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporterOptions * >(argp1);
  result = (std::string *) & ((arg1)->robotExportedName);
  _out = SWIG_From_std_string(static_cast< std::string >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ModelExporterOptions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ModelExporterOptions *result = 0 ;
  
  if (!SWIG_check_num_args("new_ModelExporterOptions",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ModelExporterOptions *)new iDynTree::ModelExporterOptions();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ModelExporterOptions, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ModelExporterOptions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporterOptions *arg1 = (iDynTree::ModelExporterOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ModelExporterOptions",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporterOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModelExporterOptions" "', argument " "1"" of type '" "iDynTree::ModelExporterOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporterOptions * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ModelExporter(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ModelExporter *result = 0 ;
  
  if (!SWIG_check_num_args("new_ModelExporter",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ModelExporter *)new iDynTree::ModelExporter();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ModelExporter, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ModelExporter(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporter *arg1 = (iDynTree::ModelExporter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ModelExporter",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModelExporter" "', argument " "1"" of type '" "iDynTree::ModelExporter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporter * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporter_exportingOptions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporter *arg1 = (iDynTree::ModelExporter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ModelExporterOptions *result = 0 ;
  
  if (!SWIG_check_num_args("ModelExporter_exportingOptions",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporter_exportingOptions" "', argument " "1"" of type '" "iDynTree::ModelExporter const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporter * >(argp1);
  result = (iDynTree::ModelExporterOptions *) &((iDynTree::ModelExporter const *)arg1)->exportingOptions();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ModelExporterOptions, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporter_setExportingOptions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporter *arg1 = (iDynTree::ModelExporter *) 0 ;
  iDynTree::ModelExporterOptions *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ModelExporter_setExportingOptions",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporter_setExportingOptions" "', argument " "1"" of type '" "iDynTree::ModelExporter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ModelExporterOptions,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelExporter_setExportingOptions" "', argument " "2"" of type '" "iDynTree::ModelExporterOptions const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelExporter_setExportingOptions" "', argument " "2"" of type '" "iDynTree::ModelExporterOptions const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ModelExporterOptions * >(argp2);
  (arg1)->setExportingOptions((iDynTree::ModelExporterOptions const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporter_init__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporter *arg1 = (iDynTree::ModelExporter *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  iDynTree::SensorsList *arg3 = 0 ;
  iDynTree::ModelExporterOptions arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelExporter_init",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporter_init" "', argument " "1"" of type '" "iDynTree::ModelExporter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelExporter_init" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelExporter_init" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SensorsList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelExporter_init" "', argument " "3"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelExporter_init" "', argument " "3"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::SensorsList * >(argp3);
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__ModelExporterOptions,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ModelExporter_init" "', argument " "4"" of type '" "iDynTree::ModelExporterOptions const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelExporter_init" "', argument " "4"" of type '" "iDynTree::ModelExporterOptions const""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::ModelExporterOptions * >(argp4));
    }
  }
  result = (bool)(arg1)->init((iDynTree::Model const &)*arg2,(iDynTree::SensorsList const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporter_init__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporter *arg1 = (iDynTree::ModelExporter *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  iDynTree::SensorsList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelExporter_init",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporter_init" "', argument " "1"" of type '" "iDynTree::ModelExporter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelExporter_init" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelExporter_init" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SensorsList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelExporter_init" "', argument " "3"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelExporter_init" "', argument " "3"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::SensorsList * >(argp3);
  result = (bool)(arg1)->init((iDynTree::Model const &)*arg2,(iDynTree::SensorsList const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporter_init__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporter *arg1 = (iDynTree::ModelExporter *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelExporter_init",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporter_init" "', argument " "1"" of type '" "iDynTree::ModelExporter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelExporter_init" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelExporter_init" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)(arg1)->init((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporter_init(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelExporter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ModelExporter_init__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelExporter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SensorsList, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModelExporter_init__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelExporter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SensorsList, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__ModelExporterOptions, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ModelExporter_init__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ModelExporter_init'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelExporter::init(iDynTree::Model const &,iDynTree::SensorsList const &,iDynTree::ModelExporterOptions const)\n"
    "    iDynTree::ModelExporter::init(iDynTree::Model const &,iDynTree::SensorsList const &)\n"
    "    iDynTree::ModelExporter::init(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_ModelExporter_model(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporter *arg1 = (iDynTree::ModelExporter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Model *result = 0 ;
  
  if (!SWIG_check_num_args("ModelExporter_model",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporter_model" "', argument " "1"" of type '" "iDynTree::ModelExporter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporter * >(argp1);
  result = (iDynTree::Model *) &(arg1)->model();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporter_sensors(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporter *arg1 = (iDynTree::ModelExporter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorsList *result = 0 ;
  
  if (!SWIG_check_num_args("ModelExporter_sensors",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporter_sensors" "', argument " "1"" of type '" "iDynTree::ModelExporter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporter * >(argp1);
  result = (iDynTree::SensorsList *) &(arg1)->sensors();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporter_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporter *arg1 = (iDynTree::ModelExporter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelExporter_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporter_isValid" "', argument " "1"" of type '" "iDynTree::ModelExporter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporter * >(argp1);
  result = (bool)(arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporter_exportModelToString__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporter *arg1 = (iDynTree::ModelExporter *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelExporter_exportModelToString",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporter_exportModelToString" "', argument " "1"" of type '" "iDynTree::ModelExporter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelExporter_exportModelToString" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelExporter_exportModelToString" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelExporter_exportModelToString" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->exportModelToString(*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporter_exportModelToString__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporter *arg1 = (iDynTree::ModelExporter *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelExporter_exportModelToString",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporter_exportModelToString" "', argument " "1"" of type '" "iDynTree::ModelExporter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelExporter_exportModelToString" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelExporter_exportModelToString" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  result = (bool)(arg1)->exportModelToString(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelExporter_exportModelToString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelExporter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ModelExporter_exportModelToString__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelExporter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModelExporter_exportModelToString__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ModelExporter_exportModelToString'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelExporter::exportModelToString(std::string &,std::string const)\n"
    "    iDynTree::ModelExporter::exportModelToString(std::string &)\n");
  return 1;
}


int _wrap_ModelExporter_exportModelToFile__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporter *arg1 = (iDynTree::ModelExporter *) 0 ;
  std::string *arg2 = 0 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelExporter_exportModelToFile",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporter_exportModelToFile" "', argument " "1"" of type '" "iDynTree::ModelExporter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporter * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelExporter_exportModelToFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelExporter_exportModelToFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelExporter_exportModelToFile" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->exportModelToFile((std::string const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ModelExporter_exportModelToFile__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelExporter *arg1 = (iDynTree::ModelExporter *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelExporter_exportModelToFile",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelExporter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelExporter_exportModelToFile" "', argument " "1"" of type '" "iDynTree::ModelExporter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelExporter * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelExporter_exportModelToFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelExporter_exportModelToFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->exportModelToFile((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ModelExporter_exportModelToFile(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelExporter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ModelExporter_exportModelToFile__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelExporter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModelExporter_exportModelToFile__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ModelExporter_exportModelToFile'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelExporter::exportModelToFile(std::string const &,std::string const)\n"
    "    iDynTree::ModelExporter::exportModelToFile(std::string const &)\n");
  return 1;
}


int _wrap_new_ModelCalibrationHelper(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ModelCalibrationHelper *result = 0 ;
  
  if (!SWIG_check_num_args("new_ModelCalibrationHelper",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ModelCalibrationHelper *)new iDynTree::ModelCalibrationHelper();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ModelCalibrationHelper(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelCalibrationHelper *arg1 = (iDynTree::ModelCalibrationHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ModelCalibrationHelper",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelCalibrationHelper, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ModelCalibrationHelper" "', argument " "1"" of type '" "iDynTree::ModelCalibrationHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelCalibrationHelper * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelCalibrationHelper_loadModelFromString__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelCalibrationHelper *arg1 = (iDynTree::ModelCalibrationHelper *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelCalibrationHelper_loadModelFromString",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCalibrationHelper_loadModelFromString" "', argument " "1"" of type '" "iDynTree::ModelCalibrationHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelCalibrationHelper * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCalibrationHelper_loadModelFromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_loadModelFromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelCalibrationHelper_loadModelFromString" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_loadModelFromString" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->loadModelFromString((std::string const &)*arg2,(std::string const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_ModelCalibrationHelper_loadModelFromString__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelCalibrationHelper *arg1 = (iDynTree::ModelCalibrationHelper *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelCalibrationHelper_loadModelFromString",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCalibrationHelper_loadModelFromString" "', argument " "1"" of type '" "iDynTree::ModelCalibrationHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelCalibrationHelper * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCalibrationHelper_loadModelFromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_loadModelFromString" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->loadModelFromString((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ModelCalibrationHelper_loadModelFromString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ModelCalibrationHelper_loadModelFromString__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModelCalibrationHelper_loadModelFromString__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ModelCalibrationHelper_loadModelFromString'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelCalibrationHelper::loadModelFromString(std::string const &,std::string const &)\n"
    "    iDynTree::ModelCalibrationHelper::loadModelFromString(std::string const &)\n");
  return 1;
}


int _wrap_ModelCalibrationHelper_loadModelFromFile__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelCalibrationHelper *arg1 = (iDynTree::ModelCalibrationHelper *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelCalibrationHelper_loadModelFromFile",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCalibrationHelper_loadModelFromFile" "', argument " "1"" of type '" "iDynTree::ModelCalibrationHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelCalibrationHelper * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCalibrationHelper_loadModelFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_loadModelFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelCalibrationHelper_loadModelFromFile" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_loadModelFromFile" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->loadModelFromFile((std::string const &)*arg2,(std::string const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_ModelCalibrationHelper_loadModelFromFile__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelCalibrationHelper *arg1 = (iDynTree::ModelCalibrationHelper *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelCalibrationHelper_loadModelFromFile",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCalibrationHelper_loadModelFromFile" "', argument " "1"" of type '" "iDynTree::ModelCalibrationHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelCalibrationHelper * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCalibrationHelper_loadModelFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_loadModelFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->loadModelFromFile((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ModelCalibrationHelper_loadModelFromFile(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ModelCalibrationHelper_loadModelFromFile__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModelCalibrationHelper_loadModelFromFile__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ModelCalibrationHelper_loadModelFromFile'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelCalibrationHelper::loadModelFromFile(std::string const &,std::string const &)\n"
    "    iDynTree::ModelCalibrationHelper::loadModelFromFile(std::string const &)\n");
  return 1;
}


int _wrap_ModelCalibrationHelper_updateModelInertialParametersToString__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelCalibrationHelper *arg1 = (iDynTree::ModelCalibrationHelper *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  std::string arg4 ;
  iDynTree::ModelExporterOptions arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelCalibrationHelper_updateModelInertialParametersToString",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "1"" of type '" "iDynTree::ModelCalibrationHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelCalibrationHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__ModelExporterOptions,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "5"" of type '" "iDynTree::ModelExporterOptions const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "5"" of type '" "iDynTree::ModelExporterOptions const""'");
    } else {
      arg5 = *(reinterpret_cast< iDynTree::ModelExporterOptions * >(argp5));
    }
  }
  result = (bool)(arg1)->updateModelInertialParametersToString(*arg2,(iDynTree::VectorDynSize const &)*arg3,arg4,arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelCalibrationHelper_updateModelInertialParametersToString__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelCalibrationHelper *arg1 = (iDynTree::ModelCalibrationHelper *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelCalibrationHelper_updateModelInertialParametersToString",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "1"" of type '" "iDynTree::ModelCalibrationHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelCalibrationHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->updateModelInertialParametersToString(*arg2,(iDynTree::VectorDynSize const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelCalibrationHelper_updateModelInertialParametersToString__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelCalibrationHelper *arg1 = (iDynTree::ModelCalibrationHelper *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelCalibrationHelper_updateModelInertialParametersToString",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "1"" of type '" "iDynTree::ModelCalibrationHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelCalibrationHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "2"" of type '" "std::string &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "2"" of type '" "std::string &""'"); 
  }
  arg2 = reinterpret_cast< std::string * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_updateModelInertialParametersToString" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  result = (bool)(arg1)->updateModelInertialParametersToString(*arg2,(iDynTree::VectorDynSize const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelCalibrationHelper_updateModelInertialParametersToString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModelCalibrationHelper_updateModelInertialParametersToString__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ModelCalibrationHelper_updateModelInertialParametersToString__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__string, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__ModelExporterOptions, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ModelCalibrationHelper_updateModelInertialParametersToString__SWIG_0(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ModelCalibrationHelper_updateModelInertialParametersToString'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelCalibrationHelper::updateModelInertialParametersToString(std::string &,iDynTree::VectorDynSize const &,std::string const,iDynTree::ModelExporterOptions const)\n"
    "    iDynTree::ModelCalibrationHelper::updateModelInertialParametersToString(std::string &,iDynTree::VectorDynSize const &,std::string const)\n"
    "    iDynTree::ModelCalibrationHelper::updateModelInertialParametersToString(std::string &,iDynTree::VectorDynSize const &)\n");
  return 1;
}


int _wrap_ModelCalibrationHelper_updateModelInertialParametersToFile__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelCalibrationHelper *arg1 = (iDynTree::ModelCalibrationHelper *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  std::string arg4 ;
  iDynTree::ModelExporterOptions arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelCalibrationHelper_updateModelInertialParametersToFile",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "1"" of type '" "iDynTree::ModelCalibrationHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelCalibrationHelper * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__ModelExporterOptions,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "5"" of type '" "iDynTree::ModelExporterOptions const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "5"" of type '" "iDynTree::ModelExporterOptions const""'");
    } else {
      arg5 = *(reinterpret_cast< iDynTree::ModelExporterOptions * >(argp5));
    }
  }
  result = (bool)(arg1)->updateModelInertialParametersToFile((std::string const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,arg4,arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ModelCalibrationHelper_updateModelInertialParametersToFile__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelCalibrationHelper *arg1 = (iDynTree::ModelCalibrationHelper *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelCalibrationHelper_updateModelInertialParametersToFile",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "1"" of type '" "iDynTree::ModelCalibrationHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelCalibrationHelper * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->updateModelInertialParametersToFile((std::string const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ModelCalibrationHelper_updateModelInertialParametersToFile__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelCalibrationHelper *arg1 = (iDynTree::ModelCalibrationHelper *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelCalibrationHelper_updateModelInertialParametersToFile",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "1"" of type '" "iDynTree::ModelCalibrationHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelCalibrationHelper * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ModelCalibrationHelper_updateModelInertialParametersToFile" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  result = (bool)(arg1)->updateModelInertialParametersToFile((std::string const &)*arg2,(iDynTree::VectorDynSize const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ModelCalibrationHelper_updateModelInertialParametersToFile(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ModelCalibrationHelper_updateModelInertialParametersToFile__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ModelCalibrationHelper_updateModelInertialParametersToFile__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__ModelExporterOptions, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ModelCalibrationHelper_updateModelInertialParametersToFile__SWIG_0(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ModelCalibrationHelper_updateModelInertialParametersToFile'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ModelCalibrationHelper::updateModelInertialParametersToFile(std::string const &,iDynTree::VectorDynSize const &,std::string const,iDynTree::ModelExporterOptions const)\n"
    "    iDynTree::ModelCalibrationHelper::updateModelInertialParametersToFile(std::string const &,iDynTree::VectorDynSize const &,std::string const)\n"
    "    iDynTree::ModelCalibrationHelper::updateModelInertialParametersToFile(std::string const &,iDynTree::VectorDynSize const &)\n");
  return 1;
}


int _wrap_ModelCalibrationHelper_model(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelCalibrationHelper *arg1 = (iDynTree::ModelCalibrationHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Model *result = 0 ;
  
  if (!SWIG_check_num_args("ModelCalibrationHelper_model",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCalibrationHelper_model" "', argument " "1"" of type '" "iDynTree::ModelCalibrationHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelCalibrationHelper * >(argp1);
  result = (iDynTree::Model *) &(arg1)->model();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelCalibrationHelper_sensors(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelCalibrationHelper *arg1 = (iDynTree::ModelCalibrationHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorsList *result = 0 ;
  
  if (!SWIG_check_num_args("ModelCalibrationHelper_sensors",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCalibrationHelper_sensors" "', argument " "1"" of type '" "iDynTree::ModelCalibrationHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelCalibrationHelper * >(argp1);
  result = (iDynTree::SensorsList *) &(arg1)->sensors();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ModelCalibrationHelper_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ModelCalibrationHelper *arg1 = (iDynTree::ModelCalibrationHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ModelCalibrationHelper_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ModelCalibrationHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ModelCalibrationHelper_isValid" "', argument " "1"" of type '" "iDynTree::ModelCalibrationHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ModelCalibrationHelper * >(argp1);
  result = (bool)(arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_UnknownWrenchContact__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::UnknownWrenchContact *result = 0 ;
  
  if (!SWIG_check_num_args("new_UnknownWrenchContact",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::UnknownWrenchContact *)new iDynTree::UnknownWrenchContact();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__UnknownWrenchContact, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_UnknownWrenchContact__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContactType arg1 ;
  iDynTree::Position *arg2 = 0 ;
  iDynTree::Direction *arg3 = 0 ;
  iDynTree::Wrench *arg4 = 0 ;
  unsigned long *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  unsigned long temp5 ;
  unsigned long val5 ;
  int ecode5 = 0 ;
  mxArray * _out;
  iDynTree::UnknownWrenchContact *result = 0 ;
  
  if (!SWIG_check_num_args("new_UnknownWrenchContact",argc,5,5,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnknownWrenchContact" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContactType""'");
  } 
  arg1 = static_cast< iDynTree::UnknownWrenchContactType >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UnknownWrenchContact" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnknownWrenchContact" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UnknownWrenchContact" "', argument " "3"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnknownWrenchContact" "', argument " "3"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Direction * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_UnknownWrenchContact" "', argument " "4"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnknownWrenchContact" "', argument " "4"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Wrench * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_UnknownWrenchContact" "', argument " "5"" of type '" "unsigned long""'");
  } 
  temp5 = static_cast< unsigned long >(val5);
  arg5 = &temp5;
  result = (iDynTree::UnknownWrenchContact *)new iDynTree::UnknownWrenchContact(arg1,(iDynTree::Position const &)*arg2,(iDynTree::Direction const &)*arg3,(iDynTree::Wrench const &)*arg4,(unsigned long const &)*arg5);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__UnknownWrenchContact, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_UnknownWrenchContact__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContactType arg1 ;
  iDynTree::Position *arg2 = 0 ;
  iDynTree::Direction *arg3 = 0 ;
  iDynTree::Wrench *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  iDynTree::UnknownWrenchContact *result = 0 ;
  
  if (!SWIG_check_num_args("new_UnknownWrenchContact",argc,4,4,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnknownWrenchContact" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContactType""'");
  } 
  arg1 = static_cast< iDynTree::UnknownWrenchContactType >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UnknownWrenchContact" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnknownWrenchContact" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UnknownWrenchContact" "', argument " "3"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnknownWrenchContact" "', argument " "3"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Direction * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Wrench,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_UnknownWrenchContact" "', argument " "4"" of type '" "iDynTree::Wrench const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnknownWrenchContact" "', argument " "4"" of type '" "iDynTree::Wrench const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Wrench * >(argp4);
  result = (iDynTree::UnknownWrenchContact *)new iDynTree::UnknownWrenchContact(arg1,(iDynTree::Position const &)*arg2,(iDynTree::Direction const &)*arg3,(iDynTree::Wrench const &)*arg4);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__UnknownWrenchContact, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_UnknownWrenchContact__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContactType arg1 ;
  iDynTree::Position *arg2 = 0 ;
  iDynTree::Direction *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::UnknownWrenchContact *result = 0 ;
  
  if (!SWIG_check_num_args("new_UnknownWrenchContact",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnknownWrenchContact" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContactType""'");
  } 
  arg1 = static_cast< iDynTree::UnknownWrenchContactType >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UnknownWrenchContact" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnknownWrenchContact" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_UnknownWrenchContact" "', argument " "3"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnknownWrenchContact" "', argument " "3"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Direction * >(argp3);
  result = (iDynTree::UnknownWrenchContact *)new iDynTree::UnknownWrenchContact(arg1,(iDynTree::Position const &)*arg2,(iDynTree::Direction const &)*arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__UnknownWrenchContact, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_UnknownWrenchContact__SWIG_4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContactType arg1 ;
  iDynTree::Position *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::UnknownWrenchContact *result = 0 ;
  
  if (!SWIG_check_num_args("new_UnknownWrenchContact",argc,2,2,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UnknownWrenchContact" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContactType""'");
  } 
  arg1 = static_cast< iDynTree::UnknownWrenchContactType >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UnknownWrenchContact" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UnknownWrenchContact" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = (iDynTree::UnknownWrenchContact *)new iDynTree::UnknownWrenchContact(arg1,(iDynTree::Position const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__UnknownWrenchContact, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_UnknownWrenchContact(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_UnknownWrenchContact__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UnknownWrenchContact__SWIG_4(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_UnknownWrenchContact__SWIG_3(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Wrench, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_UnknownWrenchContact__SWIG_2(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Wrench, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_UnknownWrenchContact__SWIG_1(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_UnknownWrenchContact'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::UnknownWrenchContact::UnknownWrenchContact()\n"
    "    iDynTree::UnknownWrenchContact::UnknownWrenchContact(iDynTree::UnknownWrenchContactType const,iDynTree::Position const &,iDynTree::Direction const &,iDynTree::Wrench const &,unsigned long const &)\n"
    "    iDynTree::UnknownWrenchContact::UnknownWrenchContact(iDynTree::UnknownWrenchContactType const,iDynTree::Position const &,iDynTree::Direction const &,iDynTree::Wrench const &)\n"
    "    iDynTree::UnknownWrenchContact::UnknownWrenchContact(iDynTree::UnknownWrenchContactType const,iDynTree::Position const &,iDynTree::Direction const &)\n"
    "    iDynTree::UnknownWrenchContact::UnknownWrenchContact(iDynTree::UnknownWrenchContactType const,iDynTree::Position const &)\n");
  return 1;
}


int _wrap_UnknownWrenchContact_unknownType_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContact *arg1 = (iDynTree::UnknownWrenchContact *) 0 ;
  iDynTree::UnknownWrenchContactType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("UnknownWrenchContact_unknownType_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__UnknownWrenchContact, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnknownWrenchContact_unknownType_set" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContact *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::UnknownWrenchContact * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnknownWrenchContact_unknownType_set" "', argument " "2"" of type '" "iDynTree::UnknownWrenchContactType""'");
  } 
  arg2 = static_cast< iDynTree::UnknownWrenchContactType >(val2);
  if (arg1) (arg1)->unknownType = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_UnknownWrenchContact_unknownType_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContact *arg1 = (iDynTree::UnknownWrenchContact *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::UnknownWrenchContactType result;
  
  if (!SWIG_check_num_args("UnknownWrenchContact_unknownType_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__UnknownWrenchContact, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnknownWrenchContact_unknownType_get" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContact *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::UnknownWrenchContact * >(argp1);
  result = (iDynTree::UnknownWrenchContactType) ((arg1)->unknownType);
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_UnknownWrenchContact_contactPoint_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContact *arg1 = (iDynTree::UnknownWrenchContact *) 0 ;
  iDynTree::Position *arg2 = (iDynTree::Position *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("UnknownWrenchContact_contactPoint_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__UnknownWrenchContact, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnknownWrenchContact_contactPoint_set" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContact *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::UnknownWrenchContact * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnknownWrenchContact_contactPoint_set" "', argument " "2"" of type '" "iDynTree::Position *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  if (arg1) (arg1)->contactPoint = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_UnknownWrenchContact_contactPoint_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContact *arg1 = (iDynTree::UnknownWrenchContact *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("UnknownWrenchContact_contactPoint_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__UnknownWrenchContact, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnknownWrenchContact_contactPoint_get" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContact *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::UnknownWrenchContact * >(argp1);
  result = (iDynTree::Position *)& ((arg1)->contactPoint);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_UnknownWrenchContact_forceDirection_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContact *arg1 = (iDynTree::UnknownWrenchContact *) 0 ;
  iDynTree::Direction *arg2 = (iDynTree::Direction *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("UnknownWrenchContact_forceDirection_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__UnknownWrenchContact, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnknownWrenchContact_forceDirection_set" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContact *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::UnknownWrenchContact * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__Direction, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnknownWrenchContact_forceDirection_set" "', argument " "2"" of type '" "iDynTree::Direction *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Direction * >(argp2);
  if (arg1) (arg1)->forceDirection = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_UnknownWrenchContact_forceDirection_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContact *arg1 = (iDynTree::UnknownWrenchContact *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Direction *result = 0 ;
  
  if (!SWIG_check_num_args("UnknownWrenchContact_forceDirection_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__UnknownWrenchContact, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnknownWrenchContact_forceDirection_get" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContact *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::UnknownWrenchContact * >(argp1);
  result = (iDynTree::Direction *)& ((arg1)->forceDirection);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Direction, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_UnknownWrenchContact_knownWrench_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContact *arg1 = (iDynTree::UnknownWrenchContact *) 0 ;
  iDynTree::Wrench *arg2 = (iDynTree::Wrench *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("UnknownWrenchContact_knownWrench_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__UnknownWrenchContact, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnknownWrenchContact_knownWrench_set" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContact *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::UnknownWrenchContact * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__Wrench, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UnknownWrenchContact_knownWrench_set" "', argument " "2"" of type '" "iDynTree::Wrench *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Wrench * >(argp2);
  if (arg1) (arg1)->knownWrench = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_UnknownWrenchContact_knownWrench_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContact *arg1 = (iDynTree::UnknownWrenchContact *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Wrench *result = 0 ;
  
  if (!SWIG_check_num_args("UnknownWrenchContact_knownWrench_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__UnknownWrenchContact, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnknownWrenchContact_knownWrench_get" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContact *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::UnknownWrenchContact * >(argp1);
  result = (iDynTree::Wrench *)& ((arg1)->knownWrench);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Wrench, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_UnknownWrenchContact_contactId_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContact *arg1 = (iDynTree::UnknownWrenchContact *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("UnknownWrenchContact_contactId_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__UnknownWrenchContact, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnknownWrenchContact_contactId_set" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContact *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::UnknownWrenchContact * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UnknownWrenchContact_contactId_set" "', argument " "2"" of type '" "unsigned long""'");
  } 
  arg2 = static_cast< unsigned long >(val2);
  if (arg1) (arg1)->contactId = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_UnknownWrenchContact_contactId_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContact *arg1 = (iDynTree::UnknownWrenchContact *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned long result;
  
  if (!SWIG_check_num_args("UnknownWrenchContact_contactId_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__UnknownWrenchContact, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UnknownWrenchContact_contactId_get" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContact *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::UnknownWrenchContact * >(argp1);
  result = (unsigned long) ((arg1)->contactId);
  _out = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_UnknownWrenchContact(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::UnknownWrenchContact *arg1 = (iDynTree::UnknownWrenchContact *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_UnknownWrenchContact",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__UnknownWrenchContact, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UnknownWrenchContact" "', argument " "1"" of type '" "iDynTree::UnknownWrenchContact *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::UnknownWrenchContact * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkUnknownWrenchContacts__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  iDynTree::LinkUnknownWrenchContacts *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkUnknownWrenchContacts",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_LinkUnknownWrenchContacts" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (iDynTree::LinkUnknownWrenchContacts *)new iDynTree::LinkUnknownWrenchContacts(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkUnknownWrenchContacts__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::LinkUnknownWrenchContacts *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkUnknownWrenchContacts",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::LinkUnknownWrenchContacts *)new iDynTree::LinkUnknownWrenchContacts();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkUnknownWrenchContacts__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkUnknownWrenchContacts *result = 0 ;
  
  if (!SWIG_check_num_args("new_LinkUnknownWrenchContacts",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinkUnknownWrenchContacts" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_LinkUnknownWrenchContacts" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  result = (iDynTree::LinkUnknownWrenchContacts *)new iDynTree::LinkUnknownWrenchContacts((iDynTree::Model const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_LinkUnknownWrenchContacts(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_LinkUnknownWrenchContacts__SWIG_1(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_LinkUnknownWrenchContacts__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_LinkUnknownWrenchContacts__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_LinkUnknownWrenchContacts'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkUnknownWrenchContacts::LinkUnknownWrenchContacts(unsigned int)\n"
    "    iDynTree::LinkUnknownWrenchContacts::LinkUnknownWrenchContacts()\n"
    "    iDynTree::LinkUnknownWrenchContacts::LinkUnknownWrenchContacts(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkUnknownWrenchContacts_clear(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkUnknownWrenchContacts *arg1 = (iDynTree::LinkUnknownWrenchContacts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkUnknownWrenchContacts_clear",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkUnknownWrenchContacts_clear" "', argument " "1"" of type '" "iDynTree::LinkUnknownWrenchContacts *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp1);
  (arg1)->clear();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkUnknownWrenchContacts_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkUnknownWrenchContacts *arg1 = (iDynTree::LinkUnknownWrenchContacts *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkUnknownWrenchContacts_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkUnknownWrenchContacts_resize" "', argument " "1"" of type '" "iDynTree::LinkUnknownWrenchContacts *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkUnknownWrenchContacts_resize" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkUnknownWrenchContacts_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkUnknownWrenchContacts *arg1 = (iDynTree::LinkUnknownWrenchContacts *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkUnknownWrenchContacts_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkUnknownWrenchContacts_resize" "', argument " "1"" of type '" "iDynTree::LinkUnknownWrenchContacts *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkUnknownWrenchContacts_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkUnknownWrenchContacts_resize" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  (arg1)->resize((iDynTree::Model const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkUnknownWrenchContacts_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LinkUnknownWrenchContacts_resize__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LinkUnknownWrenchContacts_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkUnknownWrenchContacts_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkUnknownWrenchContacts::resize(unsigned int)\n"
    "    iDynTree::LinkUnknownWrenchContacts::resize(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_LinkUnknownWrenchContacts_getNrOfContactsForLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkUnknownWrenchContacts *arg1 = (iDynTree::LinkUnknownWrenchContacts *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("LinkUnknownWrenchContacts_getNrOfContactsForLink",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkUnknownWrenchContacts_getNrOfContactsForLink" "', argument " "1"" of type '" "iDynTree::LinkUnknownWrenchContacts const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkUnknownWrenchContacts_getNrOfContactsForLink" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = ((iDynTree::LinkUnknownWrenchContacts const *)arg1)->getNrOfContactsForLink(arg2);
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkUnknownWrenchContacts_setNrOfContactsForLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkUnknownWrenchContacts *arg1 = (iDynTree::LinkUnknownWrenchContacts *) 0 ;
  iDynTree::LinkIndex arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkUnknownWrenchContacts_setNrOfContactsForLink",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkUnknownWrenchContacts_setNrOfContactsForLink" "', argument " "1"" of type '" "iDynTree::LinkUnknownWrenchContacts *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkUnknownWrenchContacts_setNrOfContactsForLink" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinkUnknownWrenchContacts_setNrOfContactsForLink" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->setNrOfContactsForLink(arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkUnknownWrenchContacts_addNewContactForLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkUnknownWrenchContacts *arg1 = (iDynTree::LinkUnknownWrenchContacts *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::UnknownWrenchContact *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("LinkUnknownWrenchContacts_addNewContactForLink",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkUnknownWrenchContacts_addNewContactForLink" "', argument " "1"" of type '" "iDynTree::LinkUnknownWrenchContacts *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkUnknownWrenchContacts_addNewContactForLink" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__UnknownWrenchContact,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LinkUnknownWrenchContacts_addNewContactForLink" "', argument " "3"" of type '" "iDynTree::UnknownWrenchContact const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkUnknownWrenchContacts_addNewContactForLink" "', argument " "3"" of type '" "iDynTree::UnknownWrenchContact const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::UnknownWrenchContact * >(argp3);
  (arg1)->addNewContactForLink(arg2,(iDynTree::UnknownWrenchContact const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkUnknownWrenchContacts_addNewContactInFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkUnknownWrenchContacts *arg1 = (iDynTree::LinkUnknownWrenchContacts *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  iDynTree::FrameIndex arg3 ;
  iDynTree::UnknownWrenchContact *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("LinkUnknownWrenchContacts_addNewContactInFrame",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkUnknownWrenchContacts_addNewContactInFrame" "', argument " "1"" of type '" "iDynTree::LinkUnknownWrenchContacts *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkUnknownWrenchContacts_addNewContactInFrame" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkUnknownWrenchContacts_addNewContactInFrame" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinkUnknownWrenchContacts_addNewContactInFrame" "', argument " "3"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg3 = static_cast< iDynTree::FrameIndex >(val3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__UnknownWrenchContact,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LinkUnknownWrenchContacts_addNewContactInFrame" "', argument " "4"" of type '" "iDynTree::UnknownWrenchContact const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkUnknownWrenchContacts_addNewContactInFrame" "', argument " "4"" of type '" "iDynTree::UnknownWrenchContact const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::UnknownWrenchContact * >(argp4);
  result = (bool)(arg1)->addNewContactInFrame((iDynTree::Model const &)*arg2,arg3,(iDynTree::UnknownWrenchContact const &)*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkUnknownWrenchContacts_addNewUnknownFullWrenchInFrameOrigin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkUnknownWrenchContacts *arg1 = (iDynTree::LinkUnknownWrenchContacts *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  iDynTree::FrameIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("LinkUnknownWrenchContacts_addNewUnknownFullWrenchInFrameOrigin",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkUnknownWrenchContacts_addNewUnknownFullWrenchInFrameOrigin" "', argument " "1"" of type '" "iDynTree::LinkUnknownWrenchContacts *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkUnknownWrenchContacts_addNewUnknownFullWrenchInFrameOrigin" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkUnknownWrenchContacts_addNewUnknownFullWrenchInFrameOrigin" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinkUnknownWrenchContacts_addNewUnknownFullWrenchInFrameOrigin" "', argument " "3"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg3 = static_cast< iDynTree::FrameIndex >(val3);
  result = (bool)(arg1)->addNewUnknownFullWrenchInFrameOrigin((iDynTree::Model const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkUnknownWrenchContacts_contactWrench__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkUnknownWrenchContacts *arg1 = (iDynTree::LinkUnknownWrenchContacts *) 0 ;
  iDynTree::LinkIndex arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::UnknownWrenchContact *result = 0 ;
  
  if (!SWIG_check_num_args("LinkUnknownWrenchContacts_contactWrench",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkUnknownWrenchContacts_contactWrench" "', argument " "1"" of type '" "iDynTree::LinkUnknownWrenchContacts *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkUnknownWrenchContacts_contactWrench" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinkUnknownWrenchContacts_contactWrench" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  result = (iDynTree::UnknownWrenchContact *) &(arg1)->contactWrench(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__UnknownWrenchContact, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkUnknownWrenchContacts_contactWrench__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkUnknownWrenchContacts *arg1 = (iDynTree::LinkUnknownWrenchContacts *) 0 ;
  iDynTree::LinkIndex arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::UnknownWrenchContact *result = 0 ;
  
  if (!SWIG_check_num_args("LinkUnknownWrenchContacts_contactWrench",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkUnknownWrenchContacts_contactWrench" "', argument " "1"" of type '" "iDynTree::LinkUnknownWrenchContacts const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinkUnknownWrenchContacts_contactWrench" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinkUnknownWrenchContacts_contactWrench" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  result = (iDynTree::UnknownWrenchContact *) &((iDynTree::LinkUnknownWrenchContacts const *)arg1)->contactWrench(arg2,arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__UnknownWrenchContact, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_LinkUnknownWrenchContacts_contactWrench(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LinkUnknownWrenchContacts_contactWrench__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LinkUnknownWrenchContacts_contactWrench__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'LinkUnknownWrenchContacts_contactWrench'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::LinkUnknownWrenchContacts::contactWrench(iDynTree::LinkIndex const,size_t const)\n"
    "    iDynTree::LinkUnknownWrenchContacts::contactWrench(iDynTree::LinkIndex const,size_t const) const\n");
  return 1;
}


int _wrap_LinkUnknownWrenchContacts_toString(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkUnknownWrenchContacts *arg1 = (iDynTree::LinkUnknownWrenchContacts *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("LinkUnknownWrenchContacts_toString",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinkUnknownWrenchContacts_toString" "', argument " "1"" of type '" "iDynTree::LinkUnknownWrenchContacts const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinkUnknownWrenchContacts_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinkUnknownWrenchContacts_toString" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = ((iDynTree::LinkUnknownWrenchContacts const *)arg1)->toString((iDynTree::Model const &)*arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_LinkUnknownWrenchContacts(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::LinkUnknownWrenchContacts *arg1 = (iDynTree::LinkUnknownWrenchContacts *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_LinkUnknownWrenchContacts",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinkUnknownWrenchContacts" "', argument " "1"" of type '" "iDynTree::LinkUnknownWrenchContacts *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_estimateExternalWrenchesBuffers__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::estimateExternalWrenchesBuffers *result = 0 ;
  
  if (!SWIG_check_num_args("new_estimateExternalWrenchesBuffers",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::estimateExternalWrenchesBuffers *)new iDynTree::estimateExternalWrenchesBuffers();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_estimateExternalWrenchesBuffers__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SubModelDecomposition *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::estimateExternalWrenchesBuffers *result = 0 ;
  
  if (!SWIG_check_num_args("new_estimateExternalWrenchesBuffers",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SubModelDecomposition,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_estimateExternalWrenchesBuffers" "', argument " "1"" of type '" "iDynTree::SubModelDecomposition const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_estimateExternalWrenchesBuffers" "', argument " "1"" of type '" "iDynTree::SubModelDecomposition const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SubModelDecomposition * >(argp1);
  result = (iDynTree::estimateExternalWrenchesBuffers *)new iDynTree::estimateExternalWrenchesBuffers((iDynTree::SubModelDecomposition const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_estimateExternalWrenchesBuffers__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  size_t arg1 ;
  size_t arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::estimateExternalWrenchesBuffers *result = 0 ;
  
  if (!SWIG_check_num_args("new_estimateExternalWrenchesBuffers",argc,2,2,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_estimateExternalWrenchesBuffers" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_estimateExternalWrenchesBuffers" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (iDynTree::estimateExternalWrenchesBuffers *)new iDynTree::estimateExternalWrenchesBuffers(arg1,arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_estimateExternalWrenchesBuffers(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_estimateExternalWrenchesBuffers__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SubModelDecomposition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_estimateExternalWrenchesBuffers__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_estimateExternalWrenchesBuffers__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_estimateExternalWrenchesBuffers'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::estimateExternalWrenchesBuffers::estimateExternalWrenchesBuffers()\n"
    "    iDynTree::estimateExternalWrenchesBuffers::estimateExternalWrenchesBuffers(iDynTree::SubModelDecomposition const &)\n"
    "    iDynTree::estimateExternalWrenchesBuffers::estimateExternalWrenchesBuffers(size_t const,size_t const)\n");
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  iDynTree::SubModelDecomposition *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_resize" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SubModelDecomposition,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "estimateExternalWrenchesBuffers_resize" "', argument " "2"" of type '" "iDynTree::SubModelDecomposition const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenchesBuffers_resize" "', argument " "2"" of type '" "iDynTree::SubModelDecomposition const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SubModelDecomposition * >(argp2);
  (arg1)->resize((iDynTree::SubModelDecomposition const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_resize",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_resize" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "estimateExternalWrenchesBuffers_resize" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "estimateExternalWrenchesBuffers_resize" "', argument " "3"" of type '" "size_t""'");
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->resize(arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SubModelDecomposition, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_estimateExternalWrenchesBuffers_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_estimateExternalWrenchesBuffers_resize__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'estimateExternalWrenchesBuffers_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::estimateExternalWrenchesBuffers::resize(iDynTree::SubModelDecomposition const &)\n"
    "    iDynTree::estimateExternalWrenchesBuffers::resize(size_t const,size_t const)\n");
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_getNrOfSubModels(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_getNrOfSubModels",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_getNrOfSubModels" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  result = ((iDynTree::estimateExternalWrenchesBuffers const *)arg1)->getNrOfSubModels();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_getNrOfLinks(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_getNrOfLinks",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_getNrOfLinks" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  result = ((iDynTree::estimateExternalWrenchesBuffers const *)arg1)->getNrOfLinks();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_isConsistent(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  iDynTree::SubModelDecomposition *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_isConsistent",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_isConsistent" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SubModelDecomposition,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "estimateExternalWrenchesBuffers_isConsistent" "', argument " "2"" of type '" "iDynTree::SubModelDecomposition const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenchesBuffers_isConsistent" "', argument " "2"" of type '" "iDynTree::SubModelDecomposition const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SubModelDecomposition * >(argp2);
  result = (bool)((iDynTree::estimateExternalWrenchesBuffers const *)arg1)->isConsistent((iDynTree::SubModelDecomposition const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_A_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  std::vector< iDynTree::MatrixDynSize,std::allocator< iDynTree::MatrixDynSize > > *arg2 = (std::vector< iDynTree::MatrixDynSize,std::allocator< iDynTree::MatrixDynSize > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_A_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_A_set" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__vectorT_iDynTree__MatrixDynSize_std__allocatorT_iDynTree__MatrixDynSize_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "estimateExternalWrenchesBuffers_A_set" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixDynSize,std::allocator< iDynTree::MatrixDynSize > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::MatrixDynSize,std::allocator< iDynTree::MatrixDynSize > > * >(argp2);
  if (arg1) (arg1)->A = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_A_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::MatrixDynSize,std::allocator< iDynTree::MatrixDynSize > > *result = 0 ;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_A_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_A_get" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  result = (std::vector< iDynTree::MatrixDynSize,std::allocator< iDynTree::MatrixDynSize > > *)& ((arg1)->A);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__MatrixDynSize_std__allocatorT_iDynTree__MatrixDynSize_t_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_x_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  std::vector< iDynTree::VectorDynSize,std::allocator< iDynTree::VectorDynSize > > *arg2 = (std::vector< iDynTree::VectorDynSize,std::allocator< iDynTree::VectorDynSize > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_x_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_x_set" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__vectorT_iDynTree__VectorDynSize_std__allocatorT_iDynTree__VectorDynSize_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "estimateExternalWrenchesBuffers_x_set" "', argument " "2"" of type '" "std::vector< iDynTree::VectorDynSize,std::allocator< iDynTree::VectorDynSize > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::VectorDynSize,std::allocator< iDynTree::VectorDynSize > > * >(argp2);
  if (arg1) (arg1)->x = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_x_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::VectorDynSize,std::allocator< iDynTree::VectorDynSize > > *result = 0 ;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_x_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_x_get" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  result = (std::vector< iDynTree::VectorDynSize,std::allocator< iDynTree::VectorDynSize > > *)& ((arg1)->x);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__VectorDynSize_std__allocatorT_iDynTree__VectorDynSize_t_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_b_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  std::vector< iDynTree::Vector6,std::allocator< iDynTree::Vector6 > > *arg2 = (std::vector< iDynTree::Vector6,std::allocator< iDynTree::Vector6 > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_b_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_b_set" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__vectorT_iDynTree__VectorFixSizeT_6_t_std__allocatorT_iDynTree__VectorFixSizeT_6_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "estimateExternalWrenchesBuffers_b_set" "', argument " "2"" of type '" "std::vector< iDynTree::Vector6,std::allocator< iDynTree::Vector6 > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::Vector6,std::allocator< iDynTree::Vector6 > > * >(argp2);
  if (arg1) (arg1)->b = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_b_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::Vector6,std::allocator< iDynTree::Vector6 > > *result = 0 ;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_b_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_b_get" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  result = (std::vector< iDynTree::Vector6,std::allocator< iDynTree::Vector6 > > *)& ((arg1)->b);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__VectorFixSizeT_6_t_std__allocatorT_iDynTree__VectorFixSizeT_6_t_t_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_pinvA_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  std::vector< iDynTree::MatrixDynSize,std::allocator< iDynTree::MatrixDynSize > > *arg2 = (std::vector< iDynTree::MatrixDynSize,std::allocator< iDynTree::MatrixDynSize > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_pinvA_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_pinvA_set" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__vectorT_iDynTree__MatrixDynSize_std__allocatorT_iDynTree__MatrixDynSize_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "estimateExternalWrenchesBuffers_pinvA_set" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixDynSize,std::allocator< iDynTree::MatrixDynSize > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::MatrixDynSize,std::allocator< iDynTree::MatrixDynSize > > * >(argp2);
  if (arg1) (arg1)->pinvA = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_pinvA_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::MatrixDynSize,std::allocator< iDynTree::MatrixDynSize > > *result = 0 ;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_pinvA_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_pinvA_get" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  result = (std::vector< iDynTree::MatrixDynSize,std::allocator< iDynTree::MatrixDynSize > > *)& ((arg1)->pinvA);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__MatrixDynSize_std__allocatorT_iDynTree__MatrixDynSize_t_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_b_contacts_subtree_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  iDynTree::LinkWrenches *arg2 = (iDynTree::LinkWrenches *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_b_contacts_subtree_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_b_contacts_subtree_set" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__LinkWrenches, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "estimateExternalWrenchesBuffers_b_contacts_subtree_set" "', argument " "2"" of type '" "iDynTree::LinkWrenches *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkWrenches * >(argp2);
  if (arg1) (arg1)->b_contacts_subtree = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_b_contacts_subtree_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkWrenches *result = 0 ;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_b_contacts_subtree_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_b_contacts_subtree_get" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  result = (iDynTree::LinkWrenches *)& ((arg1)->b_contacts_subtree);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkWrenches, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_subModelBase_H_link_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  iDynTree::LinkPositions *arg2 = (iDynTree::LinkPositions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_subModelBase_H_link_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_subModelBase_H_link_set" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__LinkPositions, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "estimateExternalWrenchesBuffers_subModelBase_H_link_set" "', argument " "2"" of type '" "iDynTree::LinkPositions *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkPositions * >(argp2);
  if (arg1) (arg1)->subModelBase_H_link = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesBuffers_subModelBase_H_link_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LinkPositions *result = 0 ;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesBuffers_subModelBase_H_link_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesBuffers_subModelBase_H_link_get" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  result = (iDynTree::LinkPositions *)& ((arg1)->subModelBase_H_link);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__LinkPositions, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_estimateExternalWrenchesBuffers(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::estimateExternalWrenchesBuffers *arg1 = (iDynTree::estimateExternalWrenchesBuffers *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_estimateExternalWrenchesBuffers",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_estimateExternalWrenchesBuffers" "', argument " "1"" of type '" "iDynTree::estimateExternalWrenchesBuffers *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenchesWithoutInternalFT(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::LinkUnknownWrenchContacts *arg3 = 0 ;
  iDynTree::JointPosDoubleArray *arg4 = 0 ;
  iDynTree::LinkVelArray *arg5 = 0 ;
  iDynTree::LinkAccArray *arg6 = 0 ;
  iDynTree::estimateExternalWrenchesBuffers *arg7 = 0 ;
  iDynTree::LinkContactWrenches *arg8 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("estimateExternalWrenchesWithoutInternalFT",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "3"" of type '" "iDynTree::LinkUnknownWrenchContacts const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "3"" of type '" "iDynTree::LinkUnknownWrenchContacts const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__JointPosDoubleArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "4"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "4"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "5"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "5"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkVelArray * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "6"" of type '" "iDynTree::LinkAccArray const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "6"" of type '" "iDynTree::LinkAccArray const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkAccArray * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "7"" of type '" "iDynTree::estimateExternalWrenchesBuffers &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "7"" of type '" "iDynTree::estimateExternalWrenchesBuffers &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp7);
  res8 = SWIG_ConvertPtr(argv[7], &argp8, SWIGTYPE_p_iDynTree__LinkContactWrenches,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "8"" of type '" "iDynTree::LinkContactWrenches &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenchesWithoutInternalFT" "', argument " "8"" of type '" "iDynTree::LinkContactWrenches &""'"); 
  }
  arg8 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp8);
  result = (bool)iDynTree::estimateExternalWrenchesWithoutInternalFT((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::LinkUnknownWrenchContacts const &)*arg3,(iDynTree::JointPosDoubleArray const &)*arg4,(iDynTree::LinkVelArray const &)*arg5,(iDynTree::LinkAccArray const &)*arg6,*arg7,*arg8);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateExternalWrenches(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::SubModelDecomposition *arg2 = 0 ;
  iDynTree::SensorsList *arg3 = 0 ;
  iDynTree::LinkUnknownWrenchContacts *arg4 = 0 ;
  iDynTree::JointPosDoubleArray *arg5 = 0 ;
  iDynTree::LinkVelArray *arg6 = 0 ;
  iDynTree::LinkAccArray *arg7 = 0 ;
  iDynTree::SensorsMeasurements *arg8 = 0 ;
  iDynTree::estimateExternalWrenchesBuffers *arg9 = 0 ;
  iDynTree::LinkContactWrenches *arg10 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("estimateExternalWrenches",argc,10,10,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateExternalWrenches" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenches" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SubModelDecomposition,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "estimateExternalWrenches" "', argument " "2"" of type '" "iDynTree::SubModelDecomposition const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenches" "', argument " "2"" of type '" "iDynTree::SubModelDecomposition const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SubModelDecomposition * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SensorsList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "estimateExternalWrenches" "', argument " "3"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenches" "', argument " "3"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::SensorsList * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "estimateExternalWrenches" "', argument " "4"" of type '" "iDynTree::LinkUnknownWrenchContacts const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenches" "', argument " "4"" of type '" "iDynTree::LinkUnknownWrenchContacts const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__JointPosDoubleArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "estimateExternalWrenches" "', argument " "5"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenches" "', argument " "5"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "estimateExternalWrenches" "', argument " "6"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenches" "', argument " "6"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkVelArray * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "estimateExternalWrenches" "', argument " "7"" of type '" "iDynTree::LinkAccArray const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenches" "', argument " "7"" of type '" "iDynTree::LinkAccArray const &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::LinkAccArray * >(argp7);
  res8 = SWIG_ConvertPtr(argv[7], &argp8, SWIGTYPE_p_iDynTree__SensorsMeasurements,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "estimateExternalWrenches" "', argument " "8"" of type '" "iDynTree::SensorsMeasurements const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenches" "', argument " "8"" of type '" "iDynTree::SensorsMeasurements const &""'"); 
  }
  arg8 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp8);
  res9 = SWIG_ConvertPtr(argv[8], &argp9, SWIGTYPE_p_iDynTree__estimateExternalWrenchesBuffers,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "estimateExternalWrenches" "', argument " "9"" of type '" "iDynTree::estimateExternalWrenchesBuffers &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenches" "', argument " "9"" of type '" "iDynTree::estimateExternalWrenchesBuffers &""'"); 
  }
  arg9 = reinterpret_cast< iDynTree::estimateExternalWrenchesBuffers * >(argp9);
  res10 = SWIG_ConvertPtr(argv[9], &argp10, SWIGTYPE_p_iDynTree__LinkContactWrenches,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "estimateExternalWrenches" "', argument " "10"" of type '" "iDynTree::LinkContactWrenches &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateExternalWrenches" "', argument " "10"" of type '" "iDynTree::LinkContactWrenches &""'"); 
  }
  arg10 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp10);
  result = (bool)iDynTree::estimateExternalWrenches((iDynTree::Model const &)*arg1,(iDynTree::SubModelDecomposition const &)*arg2,(iDynTree::SensorsList const &)*arg3,(iDynTree::LinkUnknownWrenchContacts const &)*arg4,(iDynTree::JointPosDoubleArray const &)*arg5,(iDynTree::LinkVelArray const &)*arg6,(iDynTree::LinkAccArray const &)*arg7,(iDynTree::SensorsMeasurements const &)*arg8,*arg9,*arg10);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_dynamicsEstimationForwardVelAccKinematics(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::Vector3 *arg3 = 0 ;
  iDynTree::Vector3 *arg4 = 0 ;
  iDynTree::Vector3 *arg5 = 0 ;
  iDynTree::JointPosDoubleArray *arg6 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg7 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg8 = 0 ;
  iDynTree::LinkVelArray *arg9 = 0 ;
  iDynTree::LinkAccArray *arg10 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("dynamicsEstimationForwardVelAccKinematics",argc,10,10,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "3"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "3"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "4"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "4"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Vector3 * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "5"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "5"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::Vector3 * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__JointPosDoubleArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "6"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "6"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "7"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "7"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp7);
  res8 = SWIG_ConvertPtr(argv[7], &argp8, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "8"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "8"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  arg8 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp8);
  res9 = SWIG_ConvertPtr(argv[8], &argp9, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "9"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp9) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "9"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg9 = reinterpret_cast< iDynTree::LinkVelArray * >(argp9);
  res10 = SWIG_ConvertPtr(argv[9], &argp10, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "10"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelAccKinematics" "', argument " "10"" of type '" "iDynTree::LinkAccArray &""'"); 
  }
  arg10 = reinterpret_cast< iDynTree::LinkAccArray * >(argp10);
  result = (bool)iDynTree::dynamicsEstimationForwardVelAccKinematics((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::VectorFixSize< 3 > const &)*arg3,(iDynTree::VectorFixSize< 3 > const &)*arg4,(iDynTree::VectorFixSize< 3 > const &)*arg5,(iDynTree::JointPosDoubleArray const &)*arg6,(iDynTree::JointDOFsDoubleArray const &)*arg7,(iDynTree::JointDOFsDoubleArray const &)*arg8,*arg9,*arg10);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_dynamicsEstimationForwardVelKinematics(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::Traversal *arg2 = 0 ;
  iDynTree::Vector3 *arg3 = 0 ;
  iDynTree::JointPosDoubleArray *arg4 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg5 = 0 ;
  iDynTree::LinkVelArray *arg6 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("dynamicsEstimationForwardVelKinematics",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dynamicsEstimationForwardVelKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelKinematics" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Traversal,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dynamicsEstimationForwardVelKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelKinematics" "', argument " "2"" of type '" "iDynTree::Traversal const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Traversal * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "dynamicsEstimationForwardVelKinematics" "', argument " "3"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelKinematics" "', argument " "3"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__JointPosDoubleArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dynamicsEstimationForwardVelKinematics" "', argument " "4"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelKinematics" "', argument " "4"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dynamicsEstimationForwardVelKinematics" "', argument " "5"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelKinematics" "', argument " "5"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dynamicsEstimationForwardVelKinematics" "', argument " "6"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "dynamicsEstimationForwardVelKinematics" "', argument " "6"" of type '" "iDynTree::LinkVelArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkVelArray * >(argp6);
  result = (bool)iDynTree::dynamicsEstimationForwardVelKinematics((iDynTree::Model const &)*arg1,(iDynTree::Traversal const &)*arg2,(iDynTree::VectorFixSize< 3 > const &)*arg3,(iDynTree::JointPosDoubleArray const &)*arg4,(iDynTree::JointDOFsDoubleArray const &)*arg5,*arg6);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_computeLinkNetWrenchesWithoutGravity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::LinkVelArray *arg2 = 0 ;
  iDynTree::LinkAccArray *arg3 = 0 ;
  iDynTree::LinkNetTotalWrenchesWithoutGravity *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("computeLinkNetWrenchesWithoutGravity",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "computeLinkNetWrenchesWithoutGravity" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "computeLinkNetWrenchesWithoutGravity" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__LinkVelArray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "computeLinkNetWrenchesWithoutGravity" "', argument " "2"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "computeLinkNetWrenchesWithoutGravity" "', argument " "2"" of type '" "iDynTree::LinkVelArray const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkVelArray * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "computeLinkNetWrenchesWithoutGravity" "', argument " "3"" of type '" "iDynTree::LinkAccArray const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "computeLinkNetWrenchesWithoutGravity" "', argument " "3"" of type '" "iDynTree::LinkAccArray const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::LinkAccArray * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "computeLinkNetWrenchesWithoutGravity" "', argument " "4"" of type '" "iDynTree::LinkNetTotalWrenchesWithoutGravity &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "computeLinkNetWrenchesWithoutGravity" "', argument " "4"" of type '" "iDynTree::LinkNetTotalWrenchesWithoutGravity &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkNetTotalWrenchesWithoutGravity * >(argp4);
  result = (bool)iDynTree::computeLinkNetWrenchesWithoutGravity((iDynTree::Model const &)*arg1,(iDynTree::LinkVelArray const &)*arg2,(iDynTree::LinkAccArray const &)*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateLinkContactWrenchesFromLinkNetExternalWrenches(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Model *arg1 = 0 ;
  iDynTree::LinkUnknownWrenchContacts *arg2 = 0 ;
  iDynTree::LinkNetExternalWrenches *arg3 = 0 ;
  iDynTree::LinkContactWrenches *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("estimateLinkContactWrenchesFromLinkNetExternalWrenches",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "estimateLinkContactWrenchesFromLinkNetExternalWrenches" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateLinkContactWrenchesFromLinkNetExternalWrenches" "', argument " "1"" of type '" "iDynTree::Model const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Model * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "estimateLinkContactWrenchesFromLinkNetExternalWrenches" "', argument " "2"" of type '" "iDynTree::LinkUnknownWrenchContacts const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateLinkContactWrenchesFromLinkNetExternalWrenches" "', argument " "2"" of type '" "iDynTree::LinkUnknownWrenchContacts const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "estimateLinkContactWrenchesFromLinkNetExternalWrenches" "', argument " "3"" of type '" "iDynTree::LinkNetExternalWrenches const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateLinkContactWrenchesFromLinkNetExternalWrenches" "', argument " "3"" of type '" "iDynTree::LinkNetExternalWrenches const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::LinkNetExternalWrenches * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkContactWrenches,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "estimateLinkContactWrenchesFromLinkNetExternalWrenches" "', argument " "4"" of type '" "iDynTree::LinkContactWrenches &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateLinkContactWrenchesFromLinkNetExternalWrenches" "', argument " "4"" of type '" "iDynTree::LinkContactWrenches &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp4);
  result = (bool)iDynTree::estimateLinkContactWrenchesFromLinkNetExternalWrenches((iDynTree::Model const &)*arg1,(iDynTree::LinkUnknownWrenchContacts const &)*arg2,(iDynTree::LinkWrenches const &)*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ExtWrenchesAndJointTorquesEstimator(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ExtWrenchesAndJointTorquesEstimator *result = 0 ;
  
  if (!SWIG_check_num_args("new_ExtWrenchesAndJointTorquesEstimator",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ExtWrenchesAndJointTorquesEstimator *)new iDynTree::ExtWrenchesAndJointTorquesEstimator();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ExtWrenchesAndJointTorquesEstimator(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ExtWrenchesAndJointTorquesEstimator",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ExtWrenchesAndJointTorquesEstimator" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_setModelAndSensors(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  iDynTree::SensorsList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ExtWrenchesAndJointTorquesEstimator_setModelAndSensors",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtWrenchesAndJointTorquesEstimator_setModelAndSensors" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExtWrenchesAndJointTorquesEstimator_setModelAndSensors" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_setModelAndSensors" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SensorsList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExtWrenchesAndJointTorquesEstimator_setModelAndSensors" "', argument " "3"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_setModelAndSensors" "', argument " "3"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::SensorsList * >(argp3);
  result = (bool)(arg1)->setModelAndSensors((iDynTree::Model const &)*arg2,(iDynTree::SensorsList const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  std::string arg2 ;
  std::string arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile" "', argument " "3"" of type '" "std::string const""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->loadModelAndSensorsFromFile(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->loadModelAndSensorsFromFile(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ExtWrenchesAndJointTorquesEstimator::loadModelAndSensorsFromFile(std::string const,std::string const)\n"
    "    iDynTree::ExtWrenchesAndJointTorquesEstimator::loadModelAndSensorsFromFile(std::string const)\n");
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  std::string arg2 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::string arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs" "', argument " "4"" of type '" "std::string const""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->loadModelAndSensorsFromFileWithSpecifiedDOFs(arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  std::string arg2 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->loadModelAndSensorsFromFileWithSpecifiedDOFs(arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ExtWrenchesAndJointTorquesEstimator::loadModelAndSensorsFromFileWithSpecifiedDOFs(std::string const,std::vector< std::string,std::allocator< std::string > > const &,std::string const)\n"
    "    iDynTree::ExtWrenchesAndJointTorquesEstimator::loadModelAndSensorsFromFileWithSpecifiedDOFs(std::string const,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_model(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Model *result = 0 ;
  
  if (!SWIG_check_num_args("ExtWrenchesAndJointTorquesEstimator_model",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtWrenchesAndJointTorquesEstimator_model" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  result = (iDynTree::Model *) &((iDynTree::ExtWrenchesAndJointTorquesEstimator const *)arg1)->model();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_sensors(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorsList *result = 0 ;
  
  if (!SWIG_check_num_args("ExtWrenchesAndJointTorquesEstimator_sensors",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtWrenchesAndJointTorquesEstimator_sensors" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  result = (iDynTree::SensorsList *) &((iDynTree::ExtWrenchesAndJointTorquesEstimator const *)arg1)->sensors();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_submodels(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SubModelDecomposition *result = 0 ;
  
  if (!SWIG_check_num_args("ExtWrenchesAndJointTorquesEstimator_submodels",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtWrenchesAndJointTorquesEstimator_submodels" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  result = (iDynTree::SubModelDecomposition *) &((iDynTree::ExtWrenchesAndJointTorquesEstimator const *)arg1)->submodels();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SubModelDecomposition, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  iDynTree::JointPosDoubleArray *arg2 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg3 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg4 = 0 ;
  iDynTree::FrameIndex *arg5 = 0 ;
  iDynTree::Vector3 *arg6 = 0 ;
  iDynTree::Vector3 *arg7 = 0 ;
  iDynTree::Vector3 *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  iDynTree::FrameIndex temp5 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__JointPosDoubleArray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase" "', argument " "3"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase" "', argument " "3"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase" "', argument " "4"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase" "', argument " "4"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase" "', argument " "5"" of type '" "iDynTree::FrameIndex""'");
  } 
  temp5 = static_cast< iDynTree::FrameIndex >(val5);
  arg5 = &temp5;
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase" "', argument " "6"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase" "', argument " "6"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::Vector3 * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase" "', argument " "7"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase" "', argument " "7"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::Vector3 * >(argp7);
  res8 = SWIG_ConvertPtr(argv[7], &argp8, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase" "', argument " "8"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase" "', argument " "8"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg8 = reinterpret_cast< iDynTree::Vector3 * >(argp8);
  result = (bool)(arg1)->updateKinematicsFromFloatingBase((iDynTree::JointPosDoubleArray const &)*arg2,(iDynTree::JointDOFsDoubleArray const &)*arg3,(iDynTree::JointDOFsDoubleArray const &)*arg4,(iDynTree::FrameIndex const &)*arg5,(iDynTree::Vector3 const &)*arg6,(iDynTree::Vector3 const &)*arg7,(iDynTree::Vector3 const &)*arg8);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFixedBase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  iDynTree::JointPosDoubleArray *arg2 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg3 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg4 = 0 ;
  iDynTree::FrameIndex *arg5 = 0 ;
  iDynTree::Vector3 *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  iDynTree::FrameIndex temp5 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFixedBase",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFixedBase" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__JointPosDoubleArray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFixedBase" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFixedBase" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFixedBase" "', argument " "3"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFixedBase" "', argument " "3"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFixedBase" "', argument " "4"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFixedBase" "', argument " "4"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFixedBase" "', argument " "5"" of type '" "iDynTree::FrameIndex""'");
  } 
  temp5 = static_cast< iDynTree::FrameIndex >(val5);
  arg5 = &temp5;
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFixedBase" "', argument " "6"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFixedBase" "', argument " "6"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::Vector3 * >(argp6);
  result = (bool)(arg1)->updateKinematicsFromFixedBase((iDynTree::JointPosDoubleArray const &)*arg2,(iDynTree::JointDOFsDoubleArray const &)*arg3,(iDynTree::JointDOFsDoubleArray const &)*arg4,(iDynTree::FrameIndex const &)*arg5,(iDynTree::Vector3 const &)*arg6);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_computeExpectedFTSensorsMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  iDynTree::LinkUnknownWrenchContacts *arg2 = 0 ;
  iDynTree::SensorsMeasurements *arg3 = 0 ;
  iDynTree::LinkContactWrenches *arg4 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ExtWrenchesAndJointTorquesEstimator_computeExpectedFTSensorsMeasurements",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtWrenchesAndJointTorquesEstimator_computeExpectedFTSensorsMeasurements" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExtWrenchesAndJointTorquesEstimator_computeExpectedFTSensorsMeasurements" "', argument " "2"" of type '" "iDynTree::LinkUnknownWrenchContacts const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_computeExpectedFTSensorsMeasurements" "', argument " "2"" of type '" "iDynTree::LinkUnknownWrenchContacts const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SensorsMeasurements,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExtWrenchesAndJointTorquesEstimator_computeExpectedFTSensorsMeasurements" "', argument " "3"" of type '" "iDynTree::SensorsMeasurements &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_computeExpectedFTSensorsMeasurements" "', argument " "3"" of type '" "iDynTree::SensorsMeasurements &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkContactWrenches,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ExtWrenchesAndJointTorquesEstimator_computeExpectedFTSensorsMeasurements" "', argument " "4"" of type '" "iDynTree::LinkContactWrenches &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_computeExpectedFTSensorsMeasurements" "', argument " "4"" of type '" "iDynTree::LinkContactWrenches &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ExtWrenchesAndJointTorquesEstimator_computeExpectedFTSensorsMeasurements" "', argument " "5"" of type '" "iDynTree::JointDOFsDoubleArray &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_computeExpectedFTSensorsMeasurements" "', argument " "5"" of type '" "iDynTree::JointDOFsDoubleArray &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp5);
  result = (bool)(arg1)->computeExpectedFTSensorsMeasurements((iDynTree::LinkUnknownWrenchContacts const &)*arg2,*arg3,*arg4,*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_estimateExtWrenchesAndJointTorques(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  iDynTree::LinkUnknownWrenchContacts *arg2 = 0 ;
  iDynTree::SensorsMeasurements *arg3 = 0 ;
  iDynTree::LinkContactWrenches *arg4 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ExtWrenchesAndJointTorquesEstimator_estimateExtWrenchesAndJointTorques",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtWrenchesAndJointTorquesEstimator_estimateExtWrenchesAndJointTorques" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__LinkUnknownWrenchContacts,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExtWrenchesAndJointTorquesEstimator_estimateExtWrenchesAndJointTorques" "', argument " "2"" of type '" "iDynTree::LinkUnknownWrenchContacts const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_estimateExtWrenchesAndJointTorques" "', argument " "2"" of type '" "iDynTree::LinkUnknownWrenchContacts const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkUnknownWrenchContacts * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SensorsMeasurements,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExtWrenchesAndJointTorquesEstimator_estimateExtWrenchesAndJointTorques" "', argument " "3"" of type '" "iDynTree::SensorsMeasurements const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_estimateExtWrenchesAndJointTorques" "', argument " "3"" of type '" "iDynTree::SensorsMeasurements const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkContactWrenches,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ExtWrenchesAndJointTorquesEstimator_estimateExtWrenchesAndJointTorques" "', argument " "4"" of type '" "iDynTree::LinkContactWrenches &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_estimateExtWrenchesAndJointTorques" "', argument " "4"" of type '" "iDynTree::LinkContactWrenches &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkContactWrenches * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ExtWrenchesAndJointTorquesEstimator_estimateExtWrenchesAndJointTorques" "', argument " "5"" of type '" "iDynTree::JointDOFsDoubleArray &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_estimateExtWrenchesAndJointTorques" "', argument " "5"" of type '" "iDynTree::JointDOFsDoubleArray &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp5);
  result = (bool)(arg1)->estimateExtWrenchesAndJointTorques((iDynTree::LinkUnknownWrenchContacts const &)*arg2,(iDynTree::SensorsMeasurements const &)*arg3,*arg4,*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_checkThatTheModelIsStill(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ExtWrenchesAndJointTorquesEstimator_checkThatTheModelIsStill",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtWrenchesAndJointTorquesEstimator_checkThatTheModelIsStill" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ExtWrenchesAndJointTorquesEstimator_checkThatTheModelIsStill" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ExtWrenchesAndJointTorquesEstimator_checkThatTheModelIsStill" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ExtWrenchesAndJointTorquesEstimator_checkThatTheModelIsStill" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->checkThatTheModelIsStill(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ExtWrenchesAndJointTorquesEstimator_estimateLinkNetWrenchesWithoutGravity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ExtWrenchesAndJointTorquesEstimator *arg1 = (iDynTree::ExtWrenchesAndJointTorquesEstimator *) 0 ;
  iDynTree::LinkNetTotalWrenchesWithoutGravity *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ExtWrenchesAndJointTorquesEstimator_estimateLinkNetWrenchesWithoutGravity",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtWrenchesAndJointTorquesEstimator_estimateLinkNetWrenchesWithoutGravity" "', argument " "1"" of type '" "iDynTree::ExtWrenchesAndJointTorquesEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ExtWrenchesAndJointTorquesEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExtWrenchesAndJointTorquesEstimator_estimateLinkNetWrenchesWithoutGravity" "', argument " "2"" of type '" "iDynTree::LinkNetTotalWrenchesWithoutGravity &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtWrenchesAndJointTorquesEstimator_estimateLinkNetWrenchesWithoutGravity" "', argument " "2"" of type '" "iDynTree::LinkNetTotalWrenchesWithoutGravity &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkNetTotalWrenchesWithoutGravity * >(argp2);
  result = (bool)(arg1)->estimateLinkNetWrenchesWithoutGravity(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_SimpleLeggedOdometry(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::SimpleLeggedOdometry *result = 0 ;
  
  if (!SWIG_check_num_args("new_SimpleLeggedOdometry",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::SimpleLeggedOdometry *)new iDynTree::SimpleLeggedOdometry();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_SimpleLeggedOdometry(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_SimpleLeggedOdometry",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SimpleLeggedOdometry" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SimpleLeggedOdometry_setModel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_setModel",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_setModel" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SimpleLeggedOdometry_setModel" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_setModel" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)(arg1)->setModel((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SimpleLeggedOdometry_model(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Model *result = 0 ;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_model",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_model" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  result = (iDynTree::Model *) &((iDynTree::SimpleLeggedOdometry const *)arg1)->model();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SimpleLeggedOdometry_updateKinematics(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  iDynTree::JointPosDoubleArray *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_updateKinematics",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_updateKinematics" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__JointPosDoubleArray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SimpleLeggedOdometry_updateKinematics" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_updateKinematics" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp2);
  result = (bool)(arg1)->updateKinematics(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SimpleLeggedOdometry_init__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_init",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_init" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SimpleLeggedOdometry_init" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_init" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SimpleLeggedOdometry_init" "', argument " "3"" of type '" "iDynTree::Transform const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_init" "', argument " "3"" of type '" "iDynTree::Transform const""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::Transform * >(argp3));
    }
  }
  result = (bool)(arg1)->init((std::string const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_SimpleLeggedOdometry_init__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_init",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_init" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SimpleLeggedOdometry_init" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_init" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->init((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_SimpleLeggedOdometry_init__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::Transform arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_init",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_init" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SimpleLeggedOdometry_init" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SimpleLeggedOdometry_init" "', argument " "3"" of type '" "iDynTree::Transform const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_init" "', argument " "3"" of type '" "iDynTree::Transform const""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::Transform * >(argp3));
    }
  }
  result = (bool)(arg1)->init(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SimpleLeggedOdometry_init__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  iDynTree::FrameIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_init",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_init" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SimpleLeggedOdometry_init" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  result = (bool)(arg1)->init(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SimpleLeggedOdometry_init__SWIG_4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  iDynTree::Transform arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_init",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_init" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SimpleLeggedOdometry_init" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_init" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SimpleLeggedOdometry_init" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_init" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Transform,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SimpleLeggedOdometry_init" "', argument " "4"" of type '" "iDynTree::Transform const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_init" "', argument " "4"" of type '" "iDynTree::Transform const""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::Transform * >(argp4));
    }
  }
  result = (bool)(arg1)->init((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_SimpleLeggedOdometry_init__SWIG_5(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_init",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_init" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SimpleLeggedOdometry_init" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_init" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SimpleLeggedOdometry_init" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_init" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->init((std::string const &)*arg2,(std::string const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_SimpleLeggedOdometry_init__SWIG_6(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::FrameIndex arg3 ;
  iDynTree::Transform arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_init",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_init" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SimpleLeggedOdometry_init" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SimpleLeggedOdometry_init" "', argument " "3"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg3 = static_cast< iDynTree::FrameIndex >(val3);
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Transform,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SimpleLeggedOdometry_init" "', argument " "4"" of type '" "iDynTree::Transform const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_init" "', argument " "4"" of type '" "iDynTree::Transform const""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::Transform * >(argp4));
    }
  }
  result = (bool)(arg1)->init(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SimpleLeggedOdometry_init__SWIG_7(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::FrameIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_init",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_init" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SimpleLeggedOdometry_init" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SimpleLeggedOdometry_init" "', argument " "3"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg3 = static_cast< iDynTree::FrameIndex >(val3);
  result = (bool)(arg1)->init(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SimpleLeggedOdometry_init(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SimpleLeggedOdometry_init__SWIG_3(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SimpleLeggedOdometry_init__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SimpleLeggedOdometry_init__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SimpleLeggedOdometry_init__SWIG_7(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SimpleLeggedOdometry_init__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SimpleLeggedOdometry_init__SWIG_5(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SimpleLeggedOdometry_init__SWIG_6(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SimpleLeggedOdometry_init__SWIG_4(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SimpleLeggedOdometry_init'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SimpleLeggedOdometry::init(std::string const &,iDynTree::Transform const)\n"
    "    iDynTree::SimpleLeggedOdometry::init(std::string const &)\n"
    "    iDynTree::SimpleLeggedOdometry::init(iDynTree::FrameIndex const,iDynTree::Transform const)\n"
    "    iDynTree::SimpleLeggedOdometry::init(iDynTree::FrameIndex const)\n"
    "    iDynTree::SimpleLeggedOdometry::init(std::string const &,std::string const &,iDynTree::Transform const)\n"
    "    iDynTree::SimpleLeggedOdometry::init(std::string const &,std::string const &)\n"
    "    iDynTree::SimpleLeggedOdometry::init(iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::Transform const)\n"
    "    iDynTree::SimpleLeggedOdometry::init(iDynTree::FrameIndex const,iDynTree::FrameIndex const)\n");
  return 1;
}


int _wrap_SimpleLeggedOdometry_changeFixedFrame__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_changeFixedFrame",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_changeFixedFrame" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SimpleLeggedOdometry_changeFixedFrame" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_changeFixedFrame" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->changeFixedFrame((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_SimpleLeggedOdometry_changeFixedFrame__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  iDynTree::FrameIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_changeFixedFrame",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_changeFixedFrame" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SimpleLeggedOdometry_changeFixedFrame" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  result = (bool)(arg1)->changeFixedFrame(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SimpleLeggedOdometry_changeFixedFrame__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_changeFixedFrame",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_changeFixedFrame" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SimpleLeggedOdometry_changeFixedFrame" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_changeFixedFrame" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SimpleLeggedOdometry_changeFixedFrame" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_changeFixedFrame" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)(arg1)->changeFixedFrame((std::string const &)*arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_SimpleLeggedOdometry_changeFixedFrame__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_changeFixedFrame",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_changeFixedFrame" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SimpleLeggedOdometry_changeFixedFrame" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SimpleLeggedOdometry_changeFixedFrame" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SimpleLeggedOdometry_changeFixedFrame" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)(arg1)->changeFixedFrame(arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SimpleLeggedOdometry_changeFixedFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SimpleLeggedOdometry_changeFixedFrame__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SimpleLeggedOdometry_changeFixedFrame__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SimpleLeggedOdometry_changeFixedFrame__SWIG_3(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SimpleLeggedOdometry_changeFixedFrame__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'SimpleLeggedOdometry_changeFixedFrame'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::SimpleLeggedOdometry::changeFixedFrame(std::string const &)\n"
    "    iDynTree::SimpleLeggedOdometry::changeFixedFrame(iDynTree::FrameIndex const)\n"
    "    iDynTree::SimpleLeggedOdometry::changeFixedFrame(std::string const &,iDynTree::Transform const &)\n"
    "    iDynTree::SimpleLeggedOdometry::changeFixedFrame(iDynTree::FrameIndex const,iDynTree::Transform const &)\n");
  return 1;
}


int _wrap_SimpleLeggedOdometry_getCurrentFixedLink(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_getCurrentFixedLink",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_getCurrentFixedLink" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  result = (arg1)->getCurrentFixedLink();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SimpleLeggedOdometry_getWorldLinkTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  iDynTree::LinkIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_getWorldLinkTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_getWorldLinkTransform" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SimpleLeggedOdometry_getWorldLinkTransform" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  result = (arg1)->getWorldLinkTransform(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_SimpleLeggedOdometry_getWorldFrameTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SimpleLeggedOdometry *arg1 = (iDynTree::SimpleLeggedOdometry *) 0 ;
  iDynTree::FrameIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("SimpleLeggedOdometry_getWorldFrameTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__SimpleLeggedOdometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SimpleLeggedOdometry_getWorldFrameTransform" "', argument " "1"" of type '" "iDynTree::SimpleLeggedOdometry *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SimpleLeggedOdometry * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SimpleLeggedOdometry_getWorldFrameTransform" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  result = (arg1)->getWorldFrameTransform(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_isLinkBerdyDynamicVariable(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyDynamicVariablesTypes arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("isLinkBerdyDynamicVariable",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "isLinkBerdyDynamicVariable" "', argument " "1"" of type '" "iDynTree::BerdyDynamicVariablesTypes""'");
  } 
  arg1 = static_cast< iDynTree::BerdyDynamicVariablesTypes >(val1);
  result = (bool)iDynTree::isLinkBerdyDynamicVariable(arg1);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_isJointBerdyDynamicVariable(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyDynamicVariablesTypes arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("isJointBerdyDynamicVariable",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "isJointBerdyDynamicVariable" "', argument " "1"" of type '" "iDynTree::BerdyDynamicVariablesTypes""'");
  } 
  arg1 = static_cast< iDynTree::BerdyDynamicVariablesTypes >(val1);
  result = (bool)iDynTree::isJointBerdyDynamicVariable(arg1);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_isDOFBerdyDynamicVariable(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyDynamicVariablesTypes arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("isDOFBerdyDynamicVariable",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "isDOFBerdyDynamicVariable" "', argument " "1"" of type '" "iDynTree::BerdyDynamicVariablesTypes""'");
  } 
  arg1 = static_cast< iDynTree::BerdyDynamicVariablesTypes >(val1);
  result = (bool)iDynTree::isDOFBerdyDynamicVariable(arg1);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_BerdyOptions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::BerdyOptions *result = 0 ;
  
  if (!SWIG_check_num_args("new_BerdyOptions",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::BerdyOptions *)new iDynTree::BerdyOptions();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__BerdyOptions, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_berdyVariant_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  iDynTree::BerdyVariants arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyOptions_berdyVariant_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_berdyVariant_set" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyOptions_berdyVariant_set" "', argument " "2"" of type '" "iDynTree::BerdyVariants""'");
  } 
  arg2 = static_cast< iDynTree::BerdyVariants >(val2);
  if (arg1) (arg1)->berdyVariant = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_berdyVariant_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::BerdyVariants result;
  
  if (!SWIG_check_num_args("BerdyOptions_berdyVariant_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_berdyVariant_get" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  result = (iDynTree::BerdyVariants) ((arg1)->berdyVariant);
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_includeAllNetExternalWrenchesAsDynamicVariables_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyOptions_includeAllNetExternalWrenchesAsDynamicVariables_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_includeAllNetExternalWrenchesAsDynamicVariables_set" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyOptions_includeAllNetExternalWrenchesAsDynamicVariables_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->includeAllNetExternalWrenchesAsDynamicVariables = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_includeAllNetExternalWrenchesAsDynamicVariables_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyOptions_includeAllNetExternalWrenchesAsDynamicVariables_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_includeAllNetExternalWrenchesAsDynamicVariables_get" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  result = (bool) ((arg1)->includeAllNetExternalWrenchesAsDynamicVariables);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_includeAllJointAccelerationsAsSensors_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyOptions_includeAllJointAccelerationsAsSensors_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_includeAllJointAccelerationsAsSensors_set" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyOptions_includeAllJointAccelerationsAsSensors_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->includeAllJointAccelerationsAsSensors = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_includeAllJointAccelerationsAsSensors_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyOptions_includeAllJointAccelerationsAsSensors_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_includeAllJointAccelerationsAsSensors_get" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  result = (bool) ((arg1)->includeAllJointAccelerationsAsSensors);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_includeAllJointTorquesAsSensors_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyOptions_includeAllJointTorquesAsSensors_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_includeAllJointTorquesAsSensors_set" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyOptions_includeAllJointTorquesAsSensors_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->includeAllJointTorquesAsSensors = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_includeAllJointTorquesAsSensors_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyOptions_includeAllJointTorquesAsSensors_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_includeAllJointTorquesAsSensors_get" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  result = (bool) ((arg1)->includeAllJointTorquesAsSensors);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_includeAllNetExternalWrenchesAsSensors_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyOptions_includeAllNetExternalWrenchesAsSensors_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_includeAllNetExternalWrenchesAsSensors_set" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyOptions_includeAllNetExternalWrenchesAsSensors_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->includeAllNetExternalWrenchesAsSensors = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_includeAllNetExternalWrenchesAsSensors_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyOptions_includeAllNetExternalWrenchesAsSensors_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_includeAllNetExternalWrenchesAsSensors_get" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  result = (bool) ((arg1)->includeAllNetExternalWrenchesAsSensors);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_includeFixedBaseExternalWrench_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyOptions_includeFixedBaseExternalWrench_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_includeFixedBaseExternalWrench_set" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyOptions_includeFixedBaseExternalWrench_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->includeFixedBaseExternalWrench = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_includeFixedBaseExternalWrench_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyOptions_includeFixedBaseExternalWrench_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_includeFixedBaseExternalWrench_get" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  result = (bool) ((arg1)->includeFixedBaseExternalWrench);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_jointOnWhichTheInternalWrenchIsMeasured_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = (std::vector< std::string,std::allocator< std::string > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyOptions_jointOnWhichTheInternalWrenchIsMeasured_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_jointOnWhichTheInternalWrenchIsMeasured_set" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyOptions_jointOnWhichTheInternalWrenchIsMeasured_set" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string,std::allocator< std::string > > * >(argp2);
  if (arg1) (arg1)->jointOnWhichTheInternalWrenchIsMeasured = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_jointOnWhichTheInternalWrenchIsMeasured_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  if (!SWIG_check_num_args("BerdyOptions_jointOnWhichTheInternalWrenchIsMeasured_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_jointOnWhichTheInternalWrenchIsMeasured_get" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  result = (std::vector< std::string,std::allocator< std::string > > *)& ((arg1)->jointOnWhichTheInternalWrenchIsMeasured);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_baseLink_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyOptions_baseLink_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_baseLink_set" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyOptions_baseLink_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyOptions_baseLink_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->baseLink = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_BerdyOptions_baseLink_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string *result = 0 ;
  
  if (!SWIG_check_num_args("BerdyOptions_baseLink_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_baseLink_get" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  result = (std::string *) & ((arg1)->baseLink);
  _out = SWIG_From_std_string(static_cast< std::string >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyOptions_checkConsistency(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyOptions_checkConsistency",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyOptions_checkConsistency" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  result = (bool)(arg1)->checkConsistency();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_BerdyOptions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyOptions *arg1 = (iDynTree::BerdyOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_BerdyOptions",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BerdyOptions" "', argument " "1"" of type '" "iDynTree::BerdyOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyOptions * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensor_type_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySensor *arg1 = (iDynTree::BerdySensor *) 0 ;
  iDynTree::BerdySensorTypes arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySensor_type_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensor_type_set" "', argument " "1"" of type '" "iDynTree::BerdySensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySensor * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdySensor_type_set" "', argument " "2"" of type '" "iDynTree::BerdySensorTypes""'");
  } 
  arg2 = static_cast< iDynTree::BerdySensorTypes >(val2);
  if (arg1) (arg1)->type = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensor_type_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySensor *arg1 = (iDynTree::BerdySensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::BerdySensorTypes result;
  
  if (!SWIG_check_num_args("BerdySensor_type_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensor_type_get" "', argument " "1"" of type '" "iDynTree::BerdySensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySensor * >(argp1);
  result = (iDynTree::BerdySensorTypes) ((arg1)->type);
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensor_id_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySensor *arg1 = (iDynTree::BerdySensor *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySensor_id_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensor_id_set" "', argument " "1"" of type '" "iDynTree::BerdySensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySensor * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySensor_id_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySensor_id_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->id = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_BerdySensor_id_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySensor *arg1 = (iDynTree::BerdySensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string *result = 0 ;
  
  if (!SWIG_check_num_args("BerdySensor_id_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensor_id_get" "', argument " "1"" of type '" "iDynTree::BerdySensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySensor * >(argp1);
  result = (std::string *) & ((arg1)->id);
  _out = SWIG_From_std_string(static_cast< std::string >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensor_range_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySensor *arg1 = (iDynTree::BerdySensor *) 0 ;
  iDynTree::IndexRange *arg2 = (iDynTree::IndexRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySensor_range_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensor_range_set" "', argument " "1"" of type '" "iDynTree::BerdySensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__IndexRange, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySensor_range_set" "', argument " "2"" of type '" "iDynTree::IndexRange *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::IndexRange * >(argp2);
  if (arg1) (arg1)->range = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensor_range_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySensor *arg1 = (iDynTree::BerdySensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::IndexRange *result = 0 ;
  
  if (!SWIG_check_num_args("BerdySensor_range_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensor_range_get" "', argument " "1"" of type '" "iDynTree::BerdySensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySensor * >(argp1);
  result = (iDynTree::IndexRange *)& ((arg1)->range);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IndexRange, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensor_eq(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySensor *arg1 = (iDynTree::BerdySensor *) 0 ;
  iDynTree::BerdySensor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdySensor_eq",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensor_eq" "', argument " "1"" of type '" "iDynTree::BerdySensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__BerdySensor,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySensor_eq" "', argument " "2"" of type '" "iDynTree::BerdySensor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySensor_eq" "', argument " "2"" of type '" "iDynTree::BerdySensor const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::BerdySensor * >(argp2);
  result = (bool)((iDynTree::BerdySensor const *)arg1)->operator ==((iDynTree::BerdySensor const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySensor_lt(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySensor *arg1 = (iDynTree::BerdySensor *) 0 ;
  iDynTree::BerdySensor *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdySensor_lt",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySensor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySensor_lt" "', argument " "1"" of type '" "iDynTree::BerdySensor const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySensor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__BerdySensor,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySensor_lt" "', argument " "2"" of type '" "iDynTree::BerdySensor const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySensor_lt" "', argument " "2"" of type '" "iDynTree::BerdySensor const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::BerdySensor * >(argp2);
  result = (bool)((iDynTree::BerdySensor const *)arg1)->operator <((iDynTree::BerdySensor const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_BerdySensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::BerdySensor *result = 0 ;
  
  if (!SWIG_check_num_args("new_BerdySensor",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::BerdySensor *)new iDynTree::BerdySensor();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__BerdySensor, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_BerdySensor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySensor *arg1 = (iDynTree::BerdySensor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_BerdySensor",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySensor, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BerdySensor" "', argument " "1"" of type '" "iDynTree::BerdySensor *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySensor * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariable_type_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyDynamicVariable *arg1 = (iDynTree::BerdyDynamicVariable *) 0 ;
  iDynTree::BerdyDynamicVariablesTypes arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyDynamicVariable_type_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariable_type_set" "', argument " "1"" of type '" "iDynTree::BerdyDynamicVariable *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyDynamicVariable * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyDynamicVariable_type_set" "', argument " "2"" of type '" "iDynTree::BerdyDynamicVariablesTypes""'");
  } 
  arg2 = static_cast< iDynTree::BerdyDynamicVariablesTypes >(val2);
  if (arg1) (arg1)->type = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariable_type_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyDynamicVariable *arg1 = (iDynTree::BerdyDynamicVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::BerdyDynamicVariablesTypes result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariable_type_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariable_type_get" "', argument " "1"" of type '" "iDynTree::BerdyDynamicVariable *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyDynamicVariable * >(argp1);
  result = (iDynTree::BerdyDynamicVariablesTypes) ((arg1)->type);
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariable_id_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyDynamicVariable *arg1 = (iDynTree::BerdyDynamicVariable *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyDynamicVariable_id_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariable_id_set" "', argument " "1"" of type '" "iDynTree::BerdyDynamicVariable *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyDynamicVariable * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyDynamicVariable_id_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyDynamicVariable_id_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->id = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_BerdyDynamicVariable_id_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyDynamicVariable *arg1 = (iDynTree::BerdyDynamicVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string *result = 0 ;
  
  if (!SWIG_check_num_args("BerdyDynamicVariable_id_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariable_id_get" "', argument " "1"" of type '" "iDynTree::BerdyDynamicVariable *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyDynamicVariable * >(argp1);
  result = (std::string *) & ((arg1)->id);
  _out = SWIG_From_std_string(static_cast< std::string >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariable_range_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyDynamicVariable *arg1 = (iDynTree::BerdyDynamicVariable *) 0 ;
  iDynTree::IndexRange *arg2 = (iDynTree::IndexRange *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdyDynamicVariable_range_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariable_range_set" "', argument " "1"" of type '" "iDynTree::BerdyDynamicVariable *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyDynamicVariable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__IndexRange, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyDynamicVariable_range_set" "', argument " "2"" of type '" "iDynTree::IndexRange *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::IndexRange * >(argp2);
  if (arg1) (arg1)->range = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariable_range_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyDynamicVariable *arg1 = (iDynTree::BerdyDynamicVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::IndexRange *result = 0 ;
  
  if (!SWIG_check_num_args("BerdyDynamicVariable_range_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariable_range_get" "', argument " "1"" of type '" "iDynTree::BerdyDynamicVariable *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyDynamicVariable * >(argp1);
  result = (iDynTree::IndexRange *)& ((arg1)->range);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IndexRange, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariable_eq(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyDynamicVariable *arg1 = (iDynTree::BerdyDynamicVariable *) 0 ;
  iDynTree::BerdyDynamicVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariable_eq",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariable_eq" "', argument " "1"" of type '" "iDynTree::BerdyDynamicVariable const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyDynamicVariable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__BerdyDynamicVariable,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyDynamicVariable_eq" "', argument " "2"" of type '" "iDynTree::BerdyDynamicVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyDynamicVariable_eq" "', argument " "2"" of type '" "iDynTree::BerdyDynamicVariable const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::BerdyDynamicVariable * >(argp2);
  result = (bool)((iDynTree::BerdyDynamicVariable const *)arg1)->operator ==((iDynTree::BerdyDynamicVariable const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyDynamicVariable_lt(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyDynamicVariable *arg1 = (iDynTree::BerdyDynamicVariable *) 0 ;
  iDynTree::BerdyDynamicVariable *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyDynamicVariable_lt",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyDynamicVariable_lt" "', argument " "1"" of type '" "iDynTree::BerdyDynamicVariable const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyDynamicVariable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__BerdyDynamicVariable,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyDynamicVariable_lt" "', argument " "2"" of type '" "iDynTree::BerdyDynamicVariable const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyDynamicVariable_lt" "', argument " "2"" of type '" "iDynTree::BerdyDynamicVariable const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::BerdyDynamicVariable * >(argp2);
  result = (bool)((iDynTree::BerdyDynamicVariable const *)arg1)->operator <((iDynTree::BerdyDynamicVariable const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_BerdyDynamicVariable(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::BerdyDynamicVariable *result = 0 ;
  
  if (!SWIG_check_num_args("new_BerdyDynamicVariable",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::BerdyDynamicVariable *)new iDynTree::BerdyDynamicVariable();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__BerdyDynamicVariable, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_BerdyDynamicVariable(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyDynamicVariable *arg1 = (iDynTree::BerdyDynamicVariable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_BerdyDynamicVariable",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyDynamicVariable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BerdyDynamicVariable" "', argument " "1"" of type '" "iDynTree::BerdyDynamicVariable *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyDynamicVariable * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_BerdyHelper(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::BerdyHelper *result = 0 ;
  
  if (!SWIG_check_num_args("new_BerdyHelper",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::BerdyHelper *)new iDynTree::BerdyHelper();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__BerdyHelper, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_model__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Model *result = 0 ;
  
  if (!SWIG_check_num_args("BerdyHelper_model",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_model" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  result = (iDynTree::Model *) &(arg1)->model();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_sensors__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorsList *result = 0 ;
  
  if (!SWIG_check_num_args("BerdyHelper_sensors",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_sensors" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  result = (iDynTree::SensorsList *) &(arg1)->sensors();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_dynamicTraversal(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Traversal *result = 0 ;
  
  if (!SWIG_check_num_args("BerdyHelper_dynamicTraversal",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_dynamicTraversal" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  result = (iDynTree::Traversal *) &((iDynTree::BerdyHelper const *)arg1)->dynamicTraversal();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Traversal, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_model__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Model *result = 0 ;
  
  if (!SWIG_check_num_args("BerdyHelper_model",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_model" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  result = (iDynTree::Model *) &((iDynTree::BerdyHelper const *)arg1)->model();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_model(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdyHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BerdyHelper_model__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdyHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BerdyHelper_model__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdyHelper_model'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::BerdyHelper::model()\n"
    "    iDynTree::BerdyHelper::model() const\n");
  return 1;
}


int _wrap_BerdyHelper_sensors__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SensorsList *result = 0 ;
  
  if (!SWIG_check_num_args("BerdyHelper_sensors",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_sensors" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  result = (iDynTree::SensorsList *) &((iDynTree::BerdyHelper const *)arg1)->sensors();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SensorsList, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_sensors(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdyHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BerdyHelper_sensors__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdyHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BerdyHelper_sensors__SWIG_1(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdyHelper_sensors'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::BerdyHelper::sensors()\n"
    "    iDynTree::BerdyHelper::sensors() const\n");
  return 1;
}


int _wrap_BerdyHelper_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_isValid" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  result = (bool)((iDynTree::BerdyHelper const *)arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_init__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  iDynTree::SensorsList *arg3 = 0 ;
  iDynTree::BerdyOptions arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_init",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_init" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyHelper_init" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_init" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SensorsList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_init" "', argument " "3"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_init" "', argument " "3"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::SensorsList * >(argp3);
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__BerdyOptions,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BerdyHelper_init" "', argument " "4"" of type '" "iDynTree::BerdyOptions const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_init" "', argument " "4"" of type '" "iDynTree::BerdyOptions const""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::BerdyOptions * >(argp4));
    }
  }
  result = (bool)(arg1)->init((iDynTree::Model const &)*arg2,(iDynTree::SensorsList const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_init__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  iDynTree::SensorsList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_init",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_init" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyHelper_init" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_init" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SensorsList,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_init" "', argument " "3"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_init" "', argument " "3"" of type '" "iDynTree::SensorsList const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::SensorsList * >(argp3);
  result = (bool)(arg1)->init((iDynTree::Model const &)*arg2,(iDynTree::SensorsList const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_init(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdyHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SensorsList, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BerdyHelper_init__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdyHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SensorsList, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__BerdyOptions, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_BerdyHelper_init__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdyHelper_init'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::BerdyHelper::init(iDynTree::Model const &,iDynTree::SensorsList const &,iDynTree::BerdyOptions const)\n"
    "    iDynTree::BerdyHelper::init(iDynTree::Model const &,iDynTree::SensorsList const &)\n");
  return 1;
}


int _wrap_BerdyHelper_getOptions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::BerdyOptions result;
  
  if (!SWIG_check_num_args("BerdyHelper_getOptions",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getOptions" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  result = ((iDynTree::BerdyHelper const *)arg1)->getOptions();
  _out = SWIG_NewPointerObj((new iDynTree::BerdyOptions(static_cast< const iDynTree::BerdyOptions& >(result))), SWIGTYPE_p_iDynTree__BerdyOptions, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_getNrOfDynamicVariables(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("BerdyHelper_getNrOfDynamicVariables",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getNrOfDynamicVariables" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  result = ((iDynTree::BerdyHelper const *)arg1)->getNrOfDynamicVariables();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_getNrOfDynamicEquations(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("BerdyHelper_getNrOfDynamicEquations",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getNrOfDynamicEquations" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  result = ((iDynTree::BerdyHelper const *)arg1)->getNrOfDynamicEquations();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_getNrOfSensorsMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("BerdyHelper_getNrOfSensorsMeasurements",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getNrOfSensorsMeasurements" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  result = ((iDynTree::BerdyHelper const *)arg1)->getNrOfSensorsMeasurements();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_resizeAndZeroBerdyMatrices__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg4 = 0 ;
  iDynTree::VectorDynSize *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_resizeAndZeroBerdyMatrices",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "2"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "2"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "4"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "4"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "5"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "5"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::VectorDynSize * >(argp5);
  result = (bool)(arg1)->resizeAndZeroBerdyMatrices(*arg2,*arg3,*arg4,*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_resizeAndZeroBerdyMatrices__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::MatrixDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::MatrixDynSize *arg4 = 0 ;
  iDynTree::VectorDynSize *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_resizeAndZeroBerdyMatrices",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "4"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "4"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "5"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_resizeAndZeroBerdyMatrices" "', argument " "5"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::VectorDynSize * >(argp5);
  result = (bool)(arg1)->resizeAndZeroBerdyMatrices(*arg2,*arg3,*arg4,*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_resizeAndZeroBerdyMatrices(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdyHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_BerdyHelper_resizeAndZeroBerdyMatrices__SWIG_0(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdyHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_BerdyHelper_resizeAndZeroBerdyMatrices__SWIG_1(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdyHelper_resizeAndZeroBerdyMatrices'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::BerdyHelper::resizeAndZeroBerdyMatrices(iDynTree::SparseMatrix< iDynTree::ColumnMajor > &,iDynTree::VectorDynSize &,iDynTree::SparseMatrix< iDynTree::ColumnMajor > &,iDynTree::VectorDynSize &)\n"
    "    iDynTree::BerdyHelper::resizeAndZeroBerdyMatrices(iDynTree::MatrixDynSize &,iDynTree::VectorDynSize &,iDynTree::MatrixDynSize &,iDynTree::VectorDynSize &)\n");
  return 1;
}


int _wrap_BerdyHelper_getBerdyMatrices__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg4 = 0 ;
  iDynTree::VectorDynSize *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_getBerdyMatrices",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "2"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "2"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "4"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "4"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "5"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "5"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::VectorDynSize * >(argp5);
  result = (bool)(arg1)->getBerdyMatrices(*arg2,*arg3,*arg4,*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_getBerdyMatrices__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::MatrixDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::MatrixDynSize *arg4 = 0 ;
  iDynTree::VectorDynSize *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_getBerdyMatrices",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "4"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "4"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "5"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_getBerdyMatrices" "', argument " "5"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::VectorDynSize * >(argp5);
  result = (bool)(arg1)->getBerdyMatrices(*arg2,*arg3,*arg4,*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_getBerdyMatrices(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdyHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_BerdyHelper_getBerdyMatrices__SWIG_0(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdyHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_BerdyHelper_getBerdyMatrices__SWIG_1(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdyHelper_getBerdyMatrices'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::BerdyHelper::getBerdyMatrices(iDynTree::SparseMatrix< iDynTree::ColumnMajor > &,iDynTree::VectorDynSize &,iDynTree::SparseMatrix< iDynTree::ColumnMajor > &,iDynTree::VectorDynSize &)\n"
    "    iDynTree::BerdyHelper::getBerdyMatrices(iDynTree::MatrixDynSize &,iDynTree::VectorDynSize &,iDynTree::MatrixDynSize &,iDynTree::VectorDynSize &)\n");
  return 1;
}


int _wrap_BerdyHelper_getSensorsOrdering(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdySensor,std::allocator< iDynTree::BerdySensor > > *result = 0 ;
  
  if (!SWIG_check_num_args("BerdyHelper_getSensorsOrdering",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getSensorsOrdering" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  result = (std::vector< iDynTree::BerdySensor,std::allocator< iDynTree::BerdySensor > > *) &((iDynTree::BerdyHelper const *)arg1)->getSensorsOrdering();
  _out = swig::from(static_cast< std::vector< iDynTree::BerdySensor,std::allocator< iDynTree::BerdySensor > > >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_getRangeSensorVariable(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::SensorType arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::IndexRange result;
  
  if (!SWIG_check_num_args("BerdyHelper_getRangeSensorVariable",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getRangeSensorVariable" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyHelper_getRangeSensorVariable" "', argument " "2"" of type '" "iDynTree::SensorType""'");
  } 
  arg2 = static_cast< iDynTree::SensorType >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BerdyHelper_getRangeSensorVariable" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = ((iDynTree::BerdyHelper const *)arg1)->getRangeSensorVariable(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::IndexRange(static_cast< const iDynTree::IndexRange& >(result))), SWIGTYPE_p_iDynTree__IndexRange, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_getRangeDOFSensorVariable(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::BerdySensorTypes arg2 ;
  iDynTree::DOFIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::IndexRange result;
  
  if (!SWIG_check_num_args("BerdyHelper_getRangeDOFSensorVariable",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getRangeDOFSensorVariable" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyHelper_getRangeDOFSensorVariable" "', argument " "2"" of type '" "iDynTree::BerdySensorTypes""'");
  } 
  arg2 = static_cast< iDynTree::BerdySensorTypes >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BerdyHelper_getRangeDOFSensorVariable" "', argument " "3"" of type '" "iDynTree::DOFIndex""'");
  } 
  arg3 = static_cast< iDynTree::DOFIndex >(val3);
  result = ((iDynTree::BerdyHelper const *)arg1)->getRangeDOFSensorVariable(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::IndexRange(static_cast< const iDynTree::IndexRange& >(result))), SWIGTYPE_p_iDynTree__IndexRange, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_getRangeJointSensorVariable(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::BerdySensorTypes arg2 ;
  iDynTree::JointIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::IndexRange result;
  
  if (!SWIG_check_num_args("BerdyHelper_getRangeJointSensorVariable",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getRangeJointSensorVariable" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyHelper_getRangeJointSensorVariable" "', argument " "2"" of type '" "iDynTree::BerdySensorTypes""'");
  } 
  arg2 = static_cast< iDynTree::BerdySensorTypes >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BerdyHelper_getRangeJointSensorVariable" "', argument " "3"" of type '" "iDynTree::JointIndex""'");
  } 
  arg3 = static_cast< iDynTree::JointIndex >(val3);
  result = ((iDynTree::BerdyHelper const *)arg1)->getRangeJointSensorVariable(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::IndexRange(static_cast< const iDynTree::IndexRange& >(result))), SWIGTYPE_p_iDynTree__IndexRange, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_getRangeLinkSensorVariable(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::BerdySensorTypes arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::IndexRange result;
  
  if (!SWIG_check_num_args("BerdyHelper_getRangeLinkSensorVariable",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getRangeLinkSensorVariable" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyHelper_getRangeLinkSensorVariable" "', argument " "2"" of type '" "iDynTree::BerdySensorTypes""'");
  } 
  arg2 = static_cast< iDynTree::BerdySensorTypes >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BerdyHelper_getRangeLinkSensorVariable" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  result = ((iDynTree::BerdyHelper const *)arg1)->getRangeLinkSensorVariable(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::IndexRange(static_cast< const iDynTree::IndexRange& >(result))), SWIGTYPE_p_iDynTree__IndexRange, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_getRangeLinkVariable(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::BerdyDynamicVariablesTypes arg2 ;
  iDynTree::LinkIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::IndexRange result;
  
  if (!SWIG_check_num_args("BerdyHelper_getRangeLinkVariable",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getRangeLinkVariable" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyHelper_getRangeLinkVariable" "', argument " "2"" of type '" "iDynTree::BerdyDynamicVariablesTypes""'");
  } 
  arg2 = static_cast< iDynTree::BerdyDynamicVariablesTypes >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BerdyHelper_getRangeLinkVariable" "', argument " "3"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg3 = static_cast< iDynTree::LinkIndex >(val3);
  result = ((iDynTree::BerdyHelper const *)arg1)->getRangeLinkVariable(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::IndexRange(static_cast< const iDynTree::IndexRange& >(result))), SWIGTYPE_p_iDynTree__IndexRange, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_getRangeJointVariable(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::BerdyDynamicVariablesTypes arg2 ;
  iDynTree::JointIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::IndexRange result;
  
  if (!SWIG_check_num_args("BerdyHelper_getRangeJointVariable",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getRangeJointVariable" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyHelper_getRangeJointVariable" "', argument " "2"" of type '" "iDynTree::BerdyDynamicVariablesTypes""'");
  } 
  arg2 = static_cast< iDynTree::BerdyDynamicVariablesTypes >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BerdyHelper_getRangeJointVariable" "', argument " "3"" of type '" "iDynTree::JointIndex""'");
  } 
  arg3 = static_cast< iDynTree::JointIndex >(val3);
  result = ((iDynTree::BerdyHelper const *)arg1)->getRangeJointVariable(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::IndexRange(static_cast< const iDynTree::IndexRange& >(result))), SWIGTYPE_p_iDynTree__IndexRange, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_getRangeDOFVariable(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::BerdyDynamicVariablesTypes arg2 ;
  iDynTree::DOFIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::IndexRange result;
  
  if (!SWIG_check_num_args("BerdyHelper_getRangeDOFVariable",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getRangeDOFVariable" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyHelper_getRangeDOFVariable" "', argument " "2"" of type '" "iDynTree::BerdyDynamicVariablesTypes""'");
  } 
  arg2 = static_cast< iDynTree::BerdyDynamicVariablesTypes >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BerdyHelper_getRangeDOFVariable" "', argument " "3"" of type '" "iDynTree::DOFIndex""'");
  } 
  arg3 = static_cast< iDynTree::DOFIndex >(val3);
  result = ((iDynTree::BerdyHelper const *)arg1)->getRangeDOFVariable(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::IndexRange(static_cast< const iDynTree::IndexRange& >(result))), SWIGTYPE_p_iDynTree__IndexRange, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_getDynamicVariablesOrdering(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::BerdyDynamicVariable,std::allocator< iDynTree::BerdyDynamicVariable > > *result = 0 ;
  
  if (!SWIG_check_num_args("BerdyHelper_getDynamicVariablesOrdering",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getDynamicVariablesOrdering" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  result = (std::vector< iDynTree::BerdyDynamicVariable,std::allocator< iDynTree::BerdyDynamicVariable > > *) &((iDynTree::BerdyHelper const *)arg1)->getDynamicVariablesOrdering();
  _out = swig::from(static_cast< std::vector< iDynTree::BerdyDynamicVariable,std::allocator< iDynTree::BerdyDynamicVariable > > >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_serializeDynamicVariables(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::LinkProperAccArray *arg2 = 0 ;
  iDynTree::LinkNetTotalWrenchesWithoutGravity *arg3 = 0 ;
  iDynTree::LinkNetExternalWrenches *arg4 = 0 ;
  iDynTree::LinkInternalWrenches *arg5 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg6 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg7 = 0 ;
  iDynTree::VectorDynSize *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_serializeDynamicVariables",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__LinkAccArray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "2"" of type '" "iDynTree::LinkProperAccArray &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "2"" of type '" "iDynTree::LinkProperAccArray &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkProperAccArray * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "3"" of type '" "iDynTree::LinkNetTotalWrenchesWithoutGravity &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "3"" of type '" "iDynTree::LinkNetTotalWrenchesWithoutGravity &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::LinkNetTotalWrenchesWithoutGravity * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "4"" of type '" "iDynTree::LinkNetExternalWrenches &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "4"" of type '" "iDynTree::LinkNetExternalWrenches &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkNetExternalWrenches * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "5"" of type '" "iDynTree::LinkInternalWrenches &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "5"" of type '" "iDynTree::LinkInternalWrenches &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::LinkInternalWrenches * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "6"" of type '" "iDynTree::JointDOFsDoubleArray &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "6"" of type '" "iDynTree::JointDOFsDoubleArray &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "7"" of type '" "iDynTree::JointDOFsDoubleArray &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "7"" of type '" "iDynTree::JointDOFsDoubleArray &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp7);
  res8 = SWIG_ConvertPtr(argv[7], &argp8, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "8"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeDynamicVariables" "', argument " "8"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg8 = reinterpret_cast< iDynTree::VectorDynSize * >(argp8);
  result = (bool)(arg1)->serializeDynamicVariables(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,*arg8);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_serializeSensorVariables(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::SensorsMeasurements *arg2 = 0 ;
  iDynTree::LinkNetExternalWrenches *arg3 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg4 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg5 = 0 ;
  iDynTree::LinkInternalWrenches *arg6 = 0 ;
  iDynTree::VectorDynSize *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_serializeSensorVariables",argc,7,7,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_serializeSensorVariables" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SensorsMeasurements,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyHelper_serializeSensorVariables" "', argument " "2"" of type '" "iDynTree::SensorsMeasurements &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeSensorVariables" "', argument " "2"" of type '" "iDynTree::SensorsMeasurements &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SensorsMeasurements * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_serializeSensorVariables" "', argument " "3"" of type '" "iDynTree::LinkNetExternalWrenches &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeSensorVariables" "', argument " "3"" of type '" "iDynTree::LinkNetExternalWrenches &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::LinkNetExternalWrenches * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BerdyHelper_serializeSensorVariables" "', argument " "4"" of type '" "iDynTree::JointDOFsDoubleArray &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeSensorVariables" "', argument " "4"" of type '" "iDynTree::JointDOFsDoubleArray &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BerdyHelper_serializeSensorVariables" "', argument " "5"" of type '" "iDynTree::JointDOFsDoubleArray &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeSensorVariables" "', argument " "5"" of type '" "iDynTree::JointDOFsDoubleArray &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BerdyHelper_serializeSensorVariables" "', argument " "6"" of type '" "iDynTree::LinkInternalWrenches &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeSensorVariables" "', argument " "6"" of type '" "iDynTree::LinkInternalWrenches &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::LinkInternalWrenches * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BerdyHelper_serializeSensorVariables" "', argument " "7"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeSensorVariables" "', argument " "7"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::VectorDynSize * >(argp7);
  result = (bool)(arg1)->serializeSensorVariables(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_serializeDynamicVariablesComputedFromFixedBaseRNEA(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::JointDOFsDoubleArray *arg2 = 0 ;
  iDynTree::LinkNetExternalWrenches *arg3 = 0 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_serializeDynamicVariablesComputedFromFixedBaseRNEA",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_serializeDynamicVariablesComputedFromFixedBaseRNEA" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyHelper_serializeDynamicVariablesComputedFromFixedBaseRNEA" "', argument " "2"" of type '" "iDynTree::JointDOFsDoubleArray &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeDynamicVariablesComputedFromFixedBaseRNEA" "', argument " "2"" of type '" "iDynTree::JointDOFsDoubleArray &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_serializeDynamicVariablesComputedFromFixedBaseRNEA" "', argument " "3"" of type '" "iDynTree::LinkNetExternalWrenches &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeDynamicVariablesComputedFromFixedBaseRNEA" "', argument " "3"" of type '" "iDynTree::LinkNetExternalWrenches &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::LinkNetExternalWrenches * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BerdyHelper_serializeDynamicVariablesComputedFromFixedBaseRNEA" "', argument " "4"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_serializeDynamicVariablesComputedFromFixedBaseRNEA" "', argument " "4"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  result = (bool)(arg1)->serializeDynamicVariablesComputedFromFixedBaseRNEA(*arg2,*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_extractJointTorquesFromDynamicVariables(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_extractJointTorquesFromDynamicVariables",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_extractJointTorquesFromDynamicVariables" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyHelper_extractJointTorquesFromDynamicVariables" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_extractJointTorquesFromDynamicVariables" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_extractJointTorquesFromDynamicVariables" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_extractJointTorquesFromDynamicVariables" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BerdyHelper_extractJointTorquesFromDynamicVariables" "', argument " "4"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_extractJointTorquesFromDynamicVariables" "', argument " "4"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  result = (bool)((iDynTree::BerdyHelper const *)arg1)->extractJointTorquesFromDynamicVariables((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_extractLinkNetExternalWrenchesFromDynamicVariables(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::LinkNetExternalWrenches *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_extractLinkNetExternalWrenchesFromDynamicVariables",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_extractLinkNetExternalWrenchesFromDynamicVariables" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyHelper_extractLinkNetExternalWrenchesFromDynamicVariables" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_extractLinkNetExternalWrenchesFromDynamicVariables" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_extractLinkNetExternalWrenchesFromDynamicVariables" "', argument " "3"" of type '" "iDynTree::LinkNetExternalWrenches &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_extractLinkNetExternalWrenchesFromDynamicVariables" "', argument " "3"" of type '" "iDynTree::LinkNetExternalWrenches &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::LinkNetExternalWrenches * >(argp3);
  result = (bool)((iDynTree::BerdyHelper const *)arg1)->extractLinkNetExternalWrenchesFromDynamicVariables((iDynTree::VectorDynSize const &)*arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_updateKinematicsFromFloatingBase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::JointPosDoubleArray *arg2 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg3 = 0 ;
  iDynTree::FrameIndex *arg4 = 0 ;
  iDynTree::Vector3 *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  iDynTree::FrameIndex temp4 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_updateKinematicsFromFloatingBase",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_updateKinematicsFromFloatingBase" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__JointPosDoubleArray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyHelper_updateKinematicsFromFloatingBase" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_updateKinematicsFromFloatingBase" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_updateKinematicsFromFloatingBase" "', argument " "3"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_updateKinematicsFromFloatingBase" "', argument " "3"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BerdyHelper_updateKinematicsFromFloatingBase" "', argument " "4"" of type '" "iDynTree::FrameIndex""'");
  } 
  temp4 = static_cast< iDynTree::FrameIndex >(val4);
  arg4 = &temp4;
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BerdyHelper_updateKinematicsFromFloatingBase" "', argument " "5"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_updateKinematicsFromFloatingBase" "', argument " "5"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::Vector3 * >(argp5);
  result = (bool)(arg1)->updateKinematicsFromFloatingBase((iDynTree::JointPosDoubleArray const &)*arg2,(iDynTree::JointDOFsDoubleArray const &)*arg3,(iDynTree::FrameIndex const &)*arg4,(iDynTree::Vector3 const &)*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_updateKinematicsFromFixedBase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::JointPosDoubleArray *arg2 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg3 = 0 ;
  iDynTree::FrameIndex *arg4 = 0 ;
  iDynTree::Vector3 *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  iDynTree::FrameIndex temp4 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_updateKinematicsFromFixedBase",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_updateKinematicsFromFixedBase" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__JointPosDoubleArray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyHelper_updateKinematicsFromFixedBase" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_updateKinematicsFromFixedBase" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_updateKinematicsFromFixedBase" "', argument " "3"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_updateKinematicsFromFixedBase" "', argument " "3"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BerdyHelper_updateKinematicsFromFixedBase" "', argument " "4"" of type '" "iDynTree::FrameIndex""'");
  } 
  temp4 = static_cast< iDynTree::FrameIndex >(val4);
  arg4 = &temp4;
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BerdyHelper_updateKinematicsFromFixedBase" "', argument " "5"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_updateKinematicsFromFixedBase" "', argument " "5"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::Vector3 * >(argp5);
  result = (bool)(arg1)->updateKinematicsFromFixedBase((iDynTree::JointPosDoubleArray const &)*arg2,(iDynTree::JointDOFsDoubleArray const &)*arg3,(iDynTree::FrameIndex const &)*arg4,(iDynTree::Vector3 const &)*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_updateKinematicsFromTraversalFixedBase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::JointPosDoubleArray *arg2 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg3 = 0 ;
  iDynTree::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_updateKinematicsFromTraversalFixedBase",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_updateKinematicsFromTraversalFixedBase" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__JointPosDoubleArray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdyHelper_updateKinematicsFromTraversalFixedBase" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_updateKinematicsFromTraversalFixedBase" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_updateKinematicsFromTraversalFixedBase" "', argument " "3"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_updateKinematicsFromTraversalFixedBase" "', argument " "3"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BerdyHelper_updateKinematicsFromTraversalFixedBase" "', argument " "4"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_updateKinematicsFromTraversalFixedBase" "', argument " "4"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Vector3 * >(argp4);
  result = (bool)(arg1)->updateKinematicsFromTraversalFixedBase((iDynTree::JointPosDoubleArray const &)*arg2,(iDynTree::JointDOFsDoubleArray const &)*arg3,(iDynTree::Vector3 const &)*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_setNetExternalWrenchMeasurementFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_setNetExternalWrenchMeasurementFrame",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_setNetExternalWrenchMeasurementFrame" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyHelper_setNetExternalWrenchMeasurementFrame" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_setNetExternalWrenchMeasurementFrame" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_setNetExternalWrenchMeasurementFrame" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)(arg1)->setNetExternalWrenchMeasurementFrame(arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdyHelper_getNetExternalWrenchMeasurementFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  iDynTree::LinkIndex arg2 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdyHelper_getNetExternalWrenchMeasurementFrame",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdyHelper_getNetExternalWrenchMeasurementFrame" "', argument " "1"" of type '" "iDynTree::BerdyHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BerdyHelper_getNetExternalWrenchMeasurementFrame" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  arg2 = static_cast< iDynTree::LinkIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdyHelper_getNetExternalWrenchMeasurementFrame" "', argument " "3"" of type '" "iDynTree::Transform &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdyHelper_getNetExternalWrenchMeasurementFrame" "', argument " "3"" of type '" "iDynTree::Transform &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)((iDynTree::BerdyHelper const *)arg1)->getNetExternalWrenchMeasurementFrame(arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_BerdyHelper(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = (iDynTree::BerdyHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_BerdyHelper",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdyHelper, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BerdyHelper" "', argument " "1"" of type '" "iDynTree::BerdyHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_BerdySparseMAPSolver(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdyHelper *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::BerdySparseMAPSolver *result = 0 ;
  
  if (!SWIG_check_num_args("new_BerdySparseMAPSolver",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__BerdyHelper,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BerdySparseMAPSolver" "', argument " "1"" of type '" "iDynTree::BerdyHelper &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BerdySparseMAPSolver" "', argument " "1"" of type '" "iDynTree::BerdyHelper &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdyHelper * >(argp1);
  result = (iDynTree::BerdySparseMAPSolver *)new iDynTree::BerdySparseMAPSolver(*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_BerdySparseMAPSolver(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_BerdySparseMAPSolver",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BerdySparseMAPSolver" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_setDynamicsConstraintsPriorCovariance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_setDynamicsConstraintsPriorCovariance",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_setDynamicsConstraintsPriorCovariance" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySparseMAPSolver_setDynamicsConstraintsPriorCovariance" "', argument " "2"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySparseMAPSolver_setDynamicsConstraintsPriorCovariance" "', argument " "2"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp2);
  (arg1)->setDynamicsConstraintsPriorCovariance((iDynTree::SparseMatrix< iDynTree::ColumnMajor > const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_setDynamicsRegularizationPriorCovariance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_setDynamicsRegularizationPriorCovariance",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_setDynamicsRegularizationPriorCovariance" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySparseMAPSolver_setDynamicsRegularizationPriorCovariance" "', argument " "2"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySparseMAPSolver_setDynamicsRegularizationPriorCovariance" "', argument " "2"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp2);
  (arg1)->setDynamicsRegularizationPriorCovariance((iDynTree::SparseMatrix< iDynTree::ColumnMajor > const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_setDynamicsRegularizationPriorExpectedValue(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_setDynamicsRegularizationPriorExpectedValue",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_setDynamicsRegularizationPriorExpectedValue" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySparseMAPSolver_setDynamicsRegularizationPriorExpectedValue" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySparseMAPSolver_setDynamicsRegularizationPriorExpectedValue" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  (arg1)->setDynamicsRegularizationPriorExpectedValue((iDynTree::VectorDynSize const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_setMeasurementsPriorCovariance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_setMeasurementsPriorCovariance",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_setMeasurementsPriorCovariance" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySparseMAPSolver_setMeasurementsPriorCovariance" "', argument " "2"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySparseMAPSolver_setMeasurementsPriorCovariance" "', argument " "2"" of type '" "iDynTree::SparseMatrix< iDynTree::ColumnMajor > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::SparseMatrix< iDynTree::ColumnMajor > * >(argp2);
  (arg1)->setMeasurementsPriorCovariance((iDynTree::SparseMatrix< iDynTree::ColumnMajor > const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_dynamicsConstraintsPriorCovarianceInverse__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *result = 0 ;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_dynamicsConstraintsPriorCovarianceInverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_dynamicsConstraintsPriorCovarianceInverse" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  result = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) &((iDynTree::BerdySparseMAPSolver const *)arg1)->dynamicsConstraintsPriorCovarianceInverse();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_dynamicsConstraintsPriorCovarianceInverse__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *result = 0 ;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_dynamicsConstraintsPriorCovarianceInverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_dynamicsConstraintsPriorCovarianceInverse" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  result = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) &(arg1)->dynamicsConstraintsPriorCovarianceInverse();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_dynamicsConstraintsPriorCovarianceInverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BerdySparseMAPSolver_dynamicsConstraintsPriorCovarianceInverse__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BerdySparseMAPSolver_dynamicsConstraintsPriorCovarianceInverse__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdySparseMAPSolver_dynamicsConstraintsPriorCovarianceInverse'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::BerdySparseMAPSolver::dynamicsConstraintsPriorCovarianceInverse() const\n"
    "    iDynTree::BerdySparseMAPSolver::dynamicsConstraintsPriorCovarianceInverse()\n");
  return 1;
}


int _wrap_BerdySparseMAPSolver_dynamicsRegularizationPriorCovarianceInverse__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *result = 0 ;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_dynamicsRegularizationPriorCovarianceInverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_dynamicsRegularizationPriorCovarianceInverse" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  result = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) &((iDynTree::BerdySparseMAPSolver const *)arg1)->dynamicsRegularizationPriorCovarianceInverse();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_dynamicsRegularizationPriorCovarianceInverse__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *result = 0 ;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_dynamicsRegularizationPriorCovarianceInverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_dynamicsRegularizationPriorCovarianceInverse" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  result = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) &(arg1)->dynamicsRegularizationPriorCovarianceInverse();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_dynamicsRegularizationPriorCovarianceInverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BerdySparseMAPSolver_dynamicsRegularizationPriorCovarianceInverse__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BerdySparseMAPSolver_dynamicsRegularizationPriorCovarianceInverse__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdySparseMAPSolver_dynamicsRegularizationPriorCovarianceInverse'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::BerdySparseMAPSolver::dynamicsRegularizationPriorCovarianceInverse() const\n"
    "    iDynTree::BerdySparseMAPSolver::dynamicsRegularizationPriorCovarianceInverse()\n");
  return 1;
}


int _wrap_BerdySparseMAPSolver_dynamicsRegularizationPriorExpectedValue__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::VectorDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_dynamicsRegularizationPriorExpectedValue",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_dynamicsRegularizationPriorExpectedValue" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  result = (iDynTree::VectorDynSize *) &((iDynTree::BerdySparseMAPSolver const *)arg1)->dynamicsRegularizationPriorExpectedValue();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_dynamicsRegularizationPriorExpectedValue__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::VectorDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_dynamicsRegularizationPriorExpectedValue",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_dynamicsRegularizationPriorExpectedValue" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  result = (iDynTree::VectorDynSize *) &(arg1)->dynamicsRegularizationPriorExpectedValue();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_dynamicsRegularizationPriorExpectedValue(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BerdySparseMAPSolver_dynamicsRegularizationPriorExpectedValue__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BerdySparseMAPSolver_dynamicsRegularizationPriorExpectedValue__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdySparseMAPSolver_dynamicsRegularizationPriorExpectedValue'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::BerdySparseMAPSolver::dynamicsRegularizationPriorExpectedValue() const\n"
    "    iDynTree::BerdySparseMAPSolver::dynamicsRegularizationPriorExpectedValue()\n");
  return 1;
}


int _wrap_BerdySparseMAPSolver_measurementsPriorCovarianceInverse__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *result = 0 ;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_measurementsPriorCovarianceInverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_measurementsPriorCovarianceInverse" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  result = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) &((iDynTree::BerdySparseMAPSolver const *)arg1)->measurementsPriorCovarianceInverse();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_measurementsPriorCovarianceInverse__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SparseMatrix< iDynTree::ColumnMajor > *result = 0 ;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_measurementsPriorCovarianceInverse",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_measurementsPriorCovarianceInverse" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  result = (iDynTree::SparseMatrix< iDynTree::ColumnMajor > *) &(arg1)->measurementsPriorCovarianceInverse();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_measurementsPriorCovarianceInverse(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BerdySparseMAPSolver_measurementsPriorCovarianceInverse__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BerdySparseMAPSolver_measurementsPriorCovarianceInverse__SWIG_0(resc,resv,argc,argv);
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdySparseMAPSolver_measurementsPriorCovarianceInverse'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::BerdySparseMAPSolver::measurementsPriorCovarianceInverse() const\n"
    "    iDynTree::BerdySparseMAPSolver::measurementsPriorCovarianceInverse()\n");
  return 1;
}


int _wrap_BerdySparseMAPSolver_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_isValid" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  result = (bool)(arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_initialize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_initialize",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_initialize" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  result = (bool)(arg1)->initialize();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_updateEstimateInformationFixedBase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  iDynTree::JointPosDoubleArray *arg2 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg3 = 0 ;
  iDynTree::FrameIndex arg4 ;
  iDynTree::Vector3 *arg5 = 0 ;
  iDynTree::VectorDynSize *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_updateEstimateInformationFixedBase",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_updateEstimateInformationFixedBase" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__JointPosDoubleArray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySparseMAPSolver_updateEstimateInformationFixedBase" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySparseMAPSolver_updateEstimateInformationFixedBase" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdySparseMAPSolver_updateEstimateInformationFixedBase" "', argument " "3"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySparseMAPSolver_updateEstimateInformationFixedBase" "', argument " "3"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BerdySparseMAPSolver_updateEstimateInformationFixedBase" "', argument " "4"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg4 = static_cast< iDynTree::FrameIndex >(val4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BerdySparseMAPSolver_updateEstimateInformationFixedBase" "', argument " "5"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySparseMAPSolver_updateEstimateInformationFixedBase" "', argument " "5"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::Vector3 * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BerdySparseMAPSolver_updateEstimateInformationFixedBase" "', argument " "6"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySparseMAPSolver_updateEstimateInformationFixedBase" "', argument " "6"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::VectorDynSize * >(argp6);
  (arg1)->updateEstimateInformationFixedBase((iDynTree::JointPosDoubleArray const &)*arg2,(iDynTree::JointDOFsDoubleArray const &)*arg3,arg4,(iDynTree::Vector3 const &)*arg5,(iDynTree::VectorDynSize const &)*arg6);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_updateEstimateInformationFloatingBase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  iDynTree::JointPosDoubleArray *arg2 = 0 ;
  iDynTree::JointDOFsDoubleArray *arg3 = 0 ;
  iDynTree::FrameIndex arg4 ;
  iDynTree::Vector3 *arg5 = 0 ;
  iDynTree::VectorDynSize *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_updateEstimateInformationFloatingBase",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_updateEstimateInformationFloatingBase" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__JointPosDoubleArray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySparseMAPSolver_updateEstimateInformationFloatingBase" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySparseMAPSolver_updateEstimateInformationFloatingBase" "', argument " "2"" of type '" "iDynTree::JointPosDoubleArray const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::JointPosDoubleArray * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__JointDOFsDoubleArray,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BerdySparseMAPSolver_updateEstimateInformationFloatingBase" "', argument " "3"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySparseMAPSolver_updateEstimateInformationFloatingBase" "', argument " "3"" of type '" "iDynTree::JointDOFsDoubleArray const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::JointDOFsDoubleArray * >(argp3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BerdySparseMAPSolver_updateEstimateInformationFloatingBase" "', argument " "4"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg4 = static_cast< iDynTree::FrameIndex >(val4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BerdySparseMAPSolver_updateEstimateInformationFloatingBase" "', argument " "5"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySparseMAPSolver_updateEstimateInformationFloatingBase" "', argument " "5"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::Vector3 * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BerdySparseMAPSolver_updateEstimateInformationFloatingBase" "', argument " "6"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySparseMAPSolver_updateEstimateInformationFloatingBase" "', argument " "6"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::VectorDynSize * >(argp6);
  (arg1)->updateEstimateInformationFloatingBase((iDynTree::JointPosDoubleArray const &)*arg2,(iDynTree::JointDOFsDoubleArray const &)*arg3,arg4,(iDynTree::Vector3 const &)*arg5,(iDynTree::VectorDynSize const &)*arg6);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_doEstimate(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_doEstimate",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_doEstimate" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  result = (bool)(arg1)->doEstimate();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_getLastEstimate__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_getLastEstimate",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_getLastEstimate" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BerdySparseMAPSolver_getLastEstimate" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BerdySparseMAPSolver_getLastEstimate" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  ((iDynTree::BerdySparseMAPSolver const *)arg1)->getLastEstimate(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_getLastEstimate__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::BerdySparseMAPSolver *arg1 = (iDynTree::BerdySparseMAPSolver *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::VectorDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("BerdySparseMAPSolver_getLastEstimate",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BerdySparseMAPSolver_getLastEstimate" "', argument " "1"" of type '" "iDynTree::BerdySparseMAPSolver const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::BerdySparseMAPSolver * >(argp1);
  result = (iDynTree::VectorDynSize *) &((iDynTree::BerdySparseMAPSolver const *)arg1)->getLastEstimate();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_BerdySparseMAPSolver_getLastEstimate(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BerdySparseMAPSolver_getLastEstimate__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__BerdySparseMAPSolver, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BerdySparseMAPSolver_getLastEstimate__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'BerdySparseMAPSolver_getLastEstimate'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::BerdySparseMAPSolver::getLastEstimate(iDynTree::VectorDynSize &) const\n"
    "    iDynTree::BerdySparseMAPSolver::getLastEstimate() const\n");
  return 1;
}


int _wrap_AttitudeEstimatorState_m_orientation_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeEstimatorState *arg1 = (iDynTree::AttitudeEstimatorState *) 0 ;
  iDynTree::UnitQuaternion *arg2 = (iDynTree::UnitQuaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeEstimatorState_m_orientation_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeEstimatorState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeEstimatorState_m_orientation_set" "', argument " "1"" of type '" "iDynTree::AttitudeEstimatorState *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeEstimatorState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeEstimatorState_m_orientation_set" "', argument " "2"" of type '" "iDynTree::UnitQuaternion *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::UnitQuaternion * >(argp2);
  if (arg1) (arg1)->m_orientation = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeEstimatorState_m_orientation_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeEstimatorState *arg1 = (iDynTree::AttitudeEstimatorState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::UnitQuaternion *result = 0 ;
  
  if (!SWIG_check_num_args("AttitudeEstimatorState_m_orientation_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeEstimatorState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeEstimatorState_m_orientation_get" "', argument " "1"" of type '" "iDynTree::AttitudeEstimatorState *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeEstimatorState * >(argp1);
  result = (iDynTree::UnitQuaternion *)& ((arg1)->m_orientation);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeEstimatorState_m_angular_velocity_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeEstimatorState *arg1 = (iDynTree::AttitudeEstimatorState *) 0 ;
  iDynTree::Vector3 *arg2 = (iDynTree::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeEstimatorState_m_angular_velocity_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeEstimatorState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeEstimatorState_m_angular_velocity_set" "', argument " "1"" of type '" "iDynTree::AttitudeEstimatorState *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeEstimatorState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeEstimatorState_m_angular_velocity_set" "', argument " "2"" of type '" "iDynTree::Vector3 *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector3 * >(argp2);
  if (arg1) (arg1)->m_angular_velocity = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeEstimatorState_m_angular_velocity_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeEstimatorState *arg1 = (iDynTree::AttitudeEstimatorState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Vector3 *result = 0 ;
  
  if (!SWIG_check_num_args("AttitudeEstimatorState_m_angular_velocity_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeEstimatorState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeEstimatorState_m_angular_velocity_get" "', argument " "1"" of type '" "iDynTree::AttitudeEstimatorState *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeEstimatorState * >(argp1);
  result = (iDynTree::Vector3 *)& ((arg1)->m_angular_velocity);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeEstimatorState_m_gyroscope_bias_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeEstimatorState *arg1 = (iDynTree::AttitudeEstimatorState *) 0 ;
  iDynTree::Vector3 *arg2 = (iDynTree::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeEstimatorState_m_gyroscope_bias_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeEstimatorState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeEstimatorState_m_gyroscope_bias_set" "', argument " "1"" of type '" "iDynTree::AttitudeEstimatorState *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeEstimatorState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeEstimatorState_m_gyroscope_bias_set" "', argument " "2"" of type '" "iDynTree::Vector3 *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector3 * >(argp2);
  if (arg1) (arg1)->m_gyroscope_bias = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeEstimatorState_m_gyroscope_bias_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeEstimatorState *arg1 = (iDynTree::AttitudeEstimatorState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Vector3 *result = 0 ;
  
  if (!SWIG_check_num_args("AttitudeEstimatorState_m_gyroscope_bias_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeEstimatorState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeEstimatorState_m_gyroscope_bias_get" "', argument " "1"" of type '" "iDynTree::AttitudeEstimatorState *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeEstimatorState * >(argp1);
  result = (iDynTree::Vector3 *)& ((arg1)->m_gyroscope_bias);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_AttitudeEstimatorState(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::AttitudeEstimatorState *result = 0 ;
  
  if (!SWIG_check_num_args("new_AttitudeEstimatorState",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::AttitudeEstimatorState *)new iDynTree::AttitudeEstimatorState();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__AttitudeEstimatorState, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_AttitudeEstimatorState(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeEstimatorState *arg1 = (iDynTree::AttitudeEstimatorState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_AttitudeEstimatorState",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeEstimatorState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AttitudeEstimatorState" "', argument " "1"" of type '" "iDynTree::AttitudeEstimatorState *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeEstimatorState * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_IAttitudeEstimator(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IAttitudeEstimator *arg1 = (iDynTree::IAttitudeEstimator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_IAttitudeEstimator",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IAttitudeEstimator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IAttitudeEstimator" "', argument " "1"" of type '" "iDynTree::IAttitudeEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IAttitudeEstimator * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IAttitudeEstimator_updateFilterWithMeasurements__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IAttitudeEstimator *arg1 = (iDynTree::IAttitudeEstimator *) 0 ;
  iDynTree::LinearAccelerometerMeasurements *arg2 = 0 ;
  iDynTree::GyroscopeMeasurements *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IAttitudeEstimator_updateFilterWithMeasurements",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IAttitudeEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IAttitudeEstimator_updateFilterWithMeasurements" "', argument " "1"" of type '" "iDynTree::IAttitudeEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IAttitudeEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IAttitudeEstimator_updateFilterWithMeasurements" "', argument " "2"" of type '" "iDynTree::LinearAccelerometerMeasurements const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IAttitudeEstimator_updateFilterWithMeasurements" "', argument " "2"" of type '" "iDynTree::LinearAccelerometerMeasurements const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinearAccelerometerMeasurements * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IAttitudeEstimator_updateFilterWithMeasurements" "', argument " "3"" of type '" "iDynTree::GyroscopeMeasurements const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IAttitudeEstimator_updateFilterWithMeasurements" "', argument " "3"" of type '" "iDynTree::GyroscopeMeasurements const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::GyroscopeMeasurements * >(argp3);
  result = (bool)(arg1)->updateFilterWithMeasurements((iDynTree::LinearAccelerometerMeasurements const &)*arg2,(iDynTree::GyroscopeMeasurements const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IAttitudeEstimator_updateFilterWithMeasurements__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IAttitudeEstimator *arg1 = (iDynTree::IAttitudeEstimator *) 0 ;
  iDynTree::LinearAccelerometerMeasurements *arg2 = 0 ;
  iDynTree::GyroscopeMeasurements *arg3 = 0 ;
  iDynTree::MagnetometerMeasurements *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IAttitudeEstimator_updateFilterWithMeasurements",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IAttitudeEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IAttitudeEstimator_updateFilterWithMeasurements" "', argument " "1"" of type '" "iDynTree::IAttitudeEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IAttitudeEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IAttitudeEstimator_updateFilterWithMeasurements" "', argument " "2"" of type '" "iDynTree::LinearAccelerometerMeasurements const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IAttitudeEstimator_updateFilterWithMeasurements" "', argument " "2"" of type '" "iDynTree::LinearAccelerometerMeasurements const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinearAccelerometerMeasurements * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IAttitudeEstimator_updateFilterWithMeasurements" "', argument " "3"" of type '" "iDynTree::GyroscopeMeasurements const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IAttitudeEstimator_updateFilterWithMeasurements" "', argument " "3"" of type '" "iDynTree::GyroscopeMeasurements const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::GyroscopeMeasurements * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IAttitudeEstimator_updateFilterWithMeasurements" "', argument " "4"" of type '" "iDynTree::MagnetometerMeasurements const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IAttitudeEstimator_updateFilterWithMeasurements" "', argument " "4"" of type '" "iDynTree::MagnetometerMeasurements const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::MagnetometerMeasurements * >(argp4);
  result = (bool)(arg1)->updateFilterWithMeasurements((iDynTree::LinearAccelerometerMeasurements const &)*arg2,(iDynTree::GyroscopeMeasurements const &)*arg3,(iDynTree::MagnetometerMeasurements const &)*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IAttitudeEstimator_updateFilterWithMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__IAttitudeEstimator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IAttitudeEstimator_updateFilterWithMeasurements__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__IAttitudeEstimator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_IAttitudeEstimator_updateFilterWithMeasurements__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'IAttitudeEstimator_updateFilterWithMeasurements'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::IAttitudeEstimator::updateFilterWithMeasurements(iDynTree::LinearAccelerometerMeasurements const &,iDynTree::GyroscopeMeasurements const &)\n"
    "    iDynTree::IAttitudeEstimator::updateFilterWithMeasurements(iDynTree::LinearAccelerometerMeasurements const &,iDynTree::GyroscopeMeasurements const &,iDynTree::MagnetometerMeasurements const &)\n");
  return 1;
}


int _wrap_IAttitudeEstimator_propagateStates(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IAttitudeEstimator *arg1 = (iDynTree::IAttitudeEstimator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IAttitudeEstimator_propagateStates",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IAttitudeEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IAttitudeEstimator_propagateStates" "', argument " "1"" of type '" "iDynTree::IAttitudeEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IAttitudeEstimator * >(argp1);
  result = (bool)(arg1)->propagateStates();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IAttitudeEstimator_getOrientationEstimateAsRotationMatrix(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IAttitudeEstimator *arg1 = (iDynTree::IAttitudeEstimator *) 0 ;
  iDynTree::Rotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IAttitudeEstimator_getOrientationEstimateAsRotationMatrix",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IAttitudeEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IAttitudeEstimator_getOrientationEstimateAsRotationMatrix" "', argument " "1"" of type '" "iDynTree::IAttitudeEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IAttitudeEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IAttitudeEstimator_getOrientationEstimateAsRotationMatrix" "', argument " "2"" of type '" "iDynTree::Rotation &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IAttitudeEstimator_getOrientationEstimateAsRotationMatrix" "', argument " "2"" of type '" "iDynTree::Rotation &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Rotation * >(argp2);
  result = (bool)(arg1)->getOrientationEstimateAsRotationMatrix(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IAttitudeEstimator_getOrientationEstimateAsQuaternion(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IAttitudeEstimator *arg1 = (iDynTree::IAttitudeEstimator *) 0 ;
  iDynTree::UnitQuaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IAttitudeEstimator_getOrientationEstimateAsQuaternion",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IAttitudeEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IAttitudeEstimator_getOrientationEstimateAsQuaternion" "', argument " "1"" of type '" "iDynTree::IAttitudeEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IAttitudeEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IAttitudeEstimator_getOrientationEstimateAsQuaternion" "', argument " "2"" of type '" "iDynTree::UnitQuaternion &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IAttitudeEstimator_getOrientationEstimateAsQuaternion" "', argument " "2"" of type '" "iDynTree::UnitQuaternion &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::UnitQuaternion * >(argp2);
  result = (bool)(arg1)->getOrientationEstimateAsQuaternion(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IAttitudeEstimator_getOrientationEstimateAsRPY(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IAttitudeEstimator *arg1 = (iDynTree::IAttitudeEstimator *) 0 ;
  iDynTree::RPY *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IAttitudeEstimator_getOrientationEstimateAsRPY",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IAttitudeEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IAttitudeEstimator_getOrientationEstimateAsRPY" "', argument " "1"" of type '" "iDynTree::IAttitudeEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IAttitudeEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IAttitudeEstimator_getOrientationEstimateAsRPY" "', argument " "2"" of type '" "iDynTree::RPY &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IAttitudeEstimator_getOrientationEstimateAsRPY" "', argument " "2"" of type '" "iDynTree::RPY &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::RPY * >(argp2);
  result = (bool)(arg1)->getOrientationEstimateAsRPY(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IAttitudeEstimator_getInternalStateSize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IAttitudeEstimator *arg1 = (iDynTree::IAttitudeEstimator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("IAttitudeEstimator_getInternalStateSize",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IAttitudeEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IAttitudeEstimator_getInternalStateSize" "', argument " "1"" of type '" "iDynTree::IAttitudeEstimator const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IAttitudeEstimator * >(argp1);
  result = ((iDynTree::IAttitudeEstimator const *)arg1)->getInternalStateSize();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IAttitudeEstimator_getInternalState(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IAttitudeEstimator *arg1 = (iDynTree::IAttitudeEstimator *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IAttitudeEstimator_getInternalState",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IAttitudeEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IAttitudeEstimator_getInternalState" "', argument " "1"" of type '" "iDynTree::IAttitudeEstimator const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IAttitudeEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IAttitudeEstimator_getInternalState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IAttitudeEstimator_getInternalState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)((iDynTree::IAttitudeEstimator const *)arg1)->getInternalState((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IAttitudeEstimator_getDefaultInternalInitialState(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IAttitudeEstimator *arg1 = (iDynTree::IAttitudeEstimator *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IAttitudeEstimator_getDefaultInternalInitialState",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IAttitudeEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IAttitudeEstimator_getDefaultInternalInitialState" "', argument " "1"" of type '" "iDynTree::IAttitudeEstimator const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IAttitudeEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IAttitudeEstimator_getDefaultInternalInitialState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IAttitudeEstimator_getDefaultInternalInitialState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)((iDynTree::IAttitudeEstimator const *)arg1)->getDefaultInternalInitialState((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IAttitudeEstimator_setInternalState(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IAttitudeEstimator *arg1 = (iDynTree::IAttitudeEstimator *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IAttitudeEstimator_setInternalState",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IAttitudeEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IAttitudeEstimator_setInternalState" "', argument " "1"" of type '" "iDynTree::IAttitudeEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IAttitudeEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IAttitudeEstimator_setInternalState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IAttitudeEstimator_setInternalState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)(arg1)->setInternalState((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IAttitudeEstimator_setInternalStateInitialOrientation(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IAttitudeEstimator *arg1 = (iDynTree::IAttitudeEstimator *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IAttitudeEstimator_setInternalStateInitialOrientation",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IAttitudeEstimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IAttitudeEstimator_setInternalStateInitialOrientation" "', argument " "1"" of type '" "iDynTree::IAttitudeEstimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IAttitudeEstimator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IAttitudeEstimator_setInternalStateInitialOrientation" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IAttitudeEstimator_setInternalStateInitialOrientation" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)(arg1)->setInternalStateInitialOrientation((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilterParameters_time_step_in_seconds_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilterParameters *arg1 = (iDynTree::AttitudeMahonyFilterParameters *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilterParameters_time_step_in_seconds_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilterParameters_time_step_in_seconds_set" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilterParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilterParameters * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeMahonyFilterParameters_time_step_in_seconds_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->time_step_in_seconds = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilterParameters_time_step_in_seconds_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilterParameters *arg1 = (iDynTree::AttitudeMahonyFilterParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilterParameters_time_step_in_seconds_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilterParameters_time_step_in_seconds_get" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilterParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilterParameters * >(argp1);
  result = (double) ((arg1)->time_step_in_seconds);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilterParameters_kp_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilterParameters *arg1 = (iDynTree::AttitudeMahonyFilterParameters *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilterParameters_kp_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilterParameters_kp_set" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilterParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilterParameters * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeMahonyFilterParameters_kp_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->kp = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilterParameters_kp_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilterParameters *arg1 = (iDynTree::AttitudeMahonyFilterParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilterParameters_kp_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilterParameters_kp_get" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilterParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilterParameters * >(argp1);
  result = (double) ((arg1)->kp);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilterParameters_ki_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilterParameters *arg1 = (iDynTree::AttitudeMahonyFilterParameters *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilterParameters_ki_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilterParameters_ki_set" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilterParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilterParameters * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeMahonyFilterParameters_ki_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->ki = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilterParameters_ki_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilterParameters *arg1 = (iDynTree::AttitudeMahonyFilterParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilterParameters_ki_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilterParameters_ki_get" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilterParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilterParameters * >(argp1);
  result = (double) ((arg1)->ki);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilterParameters_use_magnetometer_measurements_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilterParameters *arg1 = (iDynTree::AttitudeMahonyFilterParameters *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilterParameters_use_magnetometer_measurements_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilterParameters_use_magnetometer_measurements_set" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilterParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilterParameters * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeMahonyFilterParameters_use_magnetometer_measurements_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->use_magnetometer_measurements = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilterParameters_use_magnetometer_measurements_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilterParameters *arg1 = (iDynTree::AttitudeMahonyFilterParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilterParameters_use_magnetometer_measurements_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilterParameters_use_magnetometer_measurements_get" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilterParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilterParameters * >(argp1);
  result = (bool) ((arg1)->use_magnetometer_measurements);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilterParameters_confidence_magnetometer_measurements_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilterParameters *arg1 = (iDynTree::AttitudeMahonyFilterParameters *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilterParameters_confidence_magnetometer_measurements_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilterParameters_confidence_magnetometer_measurements_set" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilterParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilterParameters * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeMahonyFilterParameters_confidence_magnetometer_measurements_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->confidence_magnetometer_measurements = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilterParameters_confidence_magnetometer_measurements_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilterParameters *arg1 = (iDynTree::AttitudeMahonyFilterParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilterParameters_confidence_magnetometer_measurements_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilterParameters_confidence_magnetometer_measurements_get" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilterParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilterParameters * >(argp1);
  result = (double) ((arg1)->confidence_magnetometer_measurements);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_AttitudeMahonyFilterParameters(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::AttitudeMahonyFilterParameters *result = 0 ;
  
  if (!SWIG_check_num_args("new_AttitudeMahonyFilterParameters",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::AttitudeMahonyFilterParameters *)new iDynTree::AttitudeMahonyFilterParameters();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_AttitudeMahonyFilterParameters(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilterParameters *arg1 = (iDynTree::AttitudeMahonyFilterParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_AttitudeMahonyFilterParameters",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AttitudeMahonyFilterParameters" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilterParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilterParameters * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_AttitudeMahonyFilter(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::AttitudeMahonyFilter *result = 0 ;
  
  if (!SWIG_check_num_args("new_AttitudeMahonyFilter",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::AttitudeMahonyFilter *)new iDynTree::AttitudeMahonyFilter();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_useMagnetoMeterMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_useMagnetoMeterMeasurements",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_useMagnetoMeterMeasurements" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeMahonyFilter_useMagnetoMeterMeasurements" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->useMagnetoMeterMeasurements(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_setConfidenceForMagnetometerMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_setConfidenceForMagnetometerMeasurements",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_setConfidenceForMagnetometerMeasurements" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeMahonyFilter_setConfidenceForMagnetometerMeasurements" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setConfidenceForMagnetometerMeasurements(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_setGainkp(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_setGainkp",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_setGainkp" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeMahonyFilter_setGainkp" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setGainkp(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_setGainki(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_setGainki",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_setGainki" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeMahonyFilter_setGainki" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setGainki(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_setTimeStepInSeconds(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_setTimeStepInSeconds",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_setTimeStepInSeconds" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeMahonyFilter_setTimeStepInSeconds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setTimeStepInSeconds(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_setGravityDirection(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  iDynTree::Direction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_setGravityDirection",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_setGravityDirection" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeMahonyFilter_setGravityDirection" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_setGravityDirection" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Direction * >(argp2);
  (arg1)->setGravityDirection((iDynTree::Direction const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_setParameters(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  iDynTree::AttitudeMahonyFilterParameters *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_setParameters",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_setParameters" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeMahonyFilter_setParameters" "', argument " "2"" of type '" "iDynTree::AttitudeMahonyFilterParameters const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_setParameters" "', argument " "2"" of type '" "iDynTree::AttitudeMahonyFilterParameters const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::AttitudeMahonyFilterParameters * >(argp2);
  result = (bool)(arg1)->setParameters((iDynTree::AttitudeMahonyFilterParameters const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_getParameters(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  iDynTree::AttitudeMahonyFilterParameters *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_getParameters",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_getParameters" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__AttitudeMahonyFilterParameters,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeMahonyFilter_getParameters" "', argument " "2"" of type '" "iDynTree::AttitudeMahonyFilterParameters &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_getParameters" "', argument " "2"" of type '" "iDynTree::AttitudeMahonyFilterParameters &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::AttitudeMahonyFilterParameters * >(argp2);
  (arg1)->getParameters(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_updateFilterWithMeasurements__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  iDynTree::LinearAccelerometerMeasurements *arg2 = 0 ;
  iDynTree::GyroscopeMeasurements *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_updateFilterWithMeasurements",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_updateFilterWithMeasurements" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeMahonyFilter_updateFilterWithMeasurements" "', argument " "2"" of type '" "iDynTree::LinearAccelerometerMeasurements const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_updateFilterWithMeasurements" "', argument " "2"" of type '" "iDynTree::LinearAccelerometerMeasurements const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinearAccelerometerMeasurements * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AttitudeMahonyFilter_updateFilterWithMeasurements" "', argument " "3"" of type '" "iDynTree::GyroscopeMeasurements const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_updateFilterWithMeasurements" "', argument " "3"" of type '" "iDynTree::GyroscopeMeasurements const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::GyroscopeMeasurements * >(argp3);
  result = (bool)(arg1)->updateFilterWithMeasurements((iDynTree::LinearAccelerometerMeasurements const &)*arg2,(iDynTree::GyroscopeMeasurements const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_updateFilterWithMeasurements__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  iDynTree::LinearAccelerometerMeasurements *arg2 = 0 ;
  iDynTree::GyroscopeMeasurements *arg3 = 0 ;
  iDynTree::MagnetometerMeasurements *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_updateFilterWithMeasurements",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_updateFilterWithMeasurements" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeMahonyFilter_updateFilterWithMeasurements" "', argument " "2"" of type '" "iDynTree::LinearAccelerometerMeasurements const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_updateFilterWithMeasurements" "', argument " "2"" of type '" "iDynTree::LinearAccelerometerMeasurements const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinearAccelerometerMeasurements * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AttitudeMahonyFilter_updateFilterWithMeasurements" "', argument " "3"" of type '" "iDynTree::GyroscopeMeasurements const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_updateFilterWithMeasurements" "', argument " "3"" of type '" "iDynTree::GyroscopeMeasurements const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::GyroscopeMeasurements * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AttitudeMahonyFilter_updateFilterWithMeasurements" "', argument " "4"" of type '" "iDynTree::MagnetometerMeasurements const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_updateFilterWithMeasurements" "', argument " "4"" of type '" "iDynTree::MagnetometerMeasurements const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::MagnetometerMeasurements * >(argp4);
  result = (bool)(arg1)->updateFilterWithMeasurements((iDynTree::LinearAccelerometerMeasurements const &)*arg2,(iDynTree::GyroscopeMeasurements const &)*arg3,(iDynTree::MagnetometerMeasurements const &)*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_updateFilterWithMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_AttitudeMahonyFilter_updateFilterWithMeasurements__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_AttitudeMahonyFilter_updateFilterWithMeasurements__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'AttitudeMahonyFilter_updateFilterWithMeasurements'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::AttitudeMahonyFilter::updateFilterWithMeasurements(iDynTree::LinearAccelerometerMeasurements const &,iDynTree::GyroscopeMeasurements const &)\n"
    "    iDynTree::AttitudeMahonyFilter::updateFilterWithMeasurements(iDynTree::LinearAccelerometerMeasurements const &,iDynTree::GyroscopeMeasurements const &,iDynTree::MagnetometerMeasurements const &)\n");
  return 1;
}


int _wrap_AttitudeMahonyFilter_propagateStates(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_propagateStates",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_propagateStates" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  result = (bool)(arg1)->propagateStates();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_getOrientationEstimateAsRotationMatrix(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  iDynTree::Rotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_getOrientationEstimateAsRotationMatrix",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_getOrientationEstimateAsRotationMatrix" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeMahonyFilter_getOrientationEstimateAsRotationMatrix" "', argument " "2"" of type '" "iDynTree::Rotation &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_getOrientationEstimateAsRotationMatrix" "', argument " "2"" of type '" "iDynTree::Rotation &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Rotation * >(argp2);
  result = (bool)(arg1)->getOrientationEstimateAsRotationMatrix(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_getOrientationEstimateAsQuaternion(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  iDynTree::UnitQuaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_getOrientationEstimateAsQuaternion",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_getOrientationEstimateAsQuaternion" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeMahonyFilter_getOrientationEstimateAsQuaternion" "', argument " "2"" of type '" "iDynTree::UnitQuaternion &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_getOrientationEstimateAsQuaternion" "', argument " "2"" of type '" "iDynTree::UnitQuaternion &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::UnitQuaternion * >(argp2);
  result = (bool)(arg1)->getOrientationEstimateAsQuaternion(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_getOrientationEstimateAsRPY(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  iDynTree::RPY *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_getOrientationEstimateAsRPY",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_getOrientationEstimateAsRPY" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeMahonyFilter_getOrientationEstimateAsRPY" "', argument " "2"" of type '" "iDynTree::RPY &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_getOrientationEstimateAsRPY" "', argument " "2"" of type '" "iDynTree::RPY &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::RPY * >(argp2);
  result = (bool)(arg1)->getOrientationEstimateAsRPY(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_getInternalStateSize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_getInternalStateSize",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_getInternalStateSize" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  result = ((iDynTree::AttitudeMahonyFilter const *)arg1)->getInternalStateSize();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_getInternalState(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_getInternalState",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_getInternalState" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeMahonyFilter_getInternalState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_getInternalState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)((iDynTree::AttitudeMahonyFilter const *)arg1)->getInternalState((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_getDefaultInternalInitialState(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_getDefaultInternalInitialState",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_getDefaultInternalInitialState" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeMahonyFilter_getDefaultInternalInitialState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_getDefaultInternalInitialState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)((iDynTree::AttitudeMahonyFilter const *)arg1)->getDefaultInternalInitialState((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_setInternalState(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_setInternalState",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_setInternalState" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeMahonyFilter_setInternalState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_setInternalState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)(arg1)->setInternalState((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeMahonyFilter_setInternalStateInitialOrientation(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeMahonyFilter_setInternalStateInitialOrientation",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeMahonyFilter_setInternalStateInitialOrientation" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeMahonyFilter_setInternalStateInitialOrientation" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeMahonyFilter_setInternalStateInitialOrientation" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)(arg1)->setInternalStateInitialOrientation((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_AttitudeMahonyFilter(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeMahonyFilter *arg1 = (iDynTree::AttitudeMahonyFilter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_AttitudeMahonyFilter",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeMahonyFilter, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AttitudeMahonyFilter" "', argument " "1"" of type '" "iDynTree::AttitudeMahonyFilter *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeMahonyFilter * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekf_f(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekf_f",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekf_f" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekf_f" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekf_f" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiscreteExtendedKalmanFilterHelper_ekf_f" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekf_f" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiscreteExtendedKalmanFilterHelper_ekf_f" "', argument " "4"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekf_f" "', argument " "4"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  result = (bool)(arg1)->ekf_f((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekf_h(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekf_h",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekf_h" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekf_h" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekf_h" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiscreteExtendedKalmanFilterHelper_ekf_h" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekf_h" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  result = (bool)(arg1)->ekf_h((iDynTree::VectorDynSize const &)*arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::MatrixDynSize *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF" "', argument " "3"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF" "', argument " "3"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp3);
  result = (bool)(arg1)->ekfComputeJacobianF(*arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::MatrixDynSize *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF" "', argument " "4"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF" "', argument " "4"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp4);
  result = (bool)(arg1)->ekfComputeJacobianF(*arg2,*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::DiscreteExtendedKalmanFilterHelper::ekfComputeJacobianF(iDynTree::VectorDynSize &,iDynTree::MatrixDynSize &)\n"
    "    iDynTree::DiscreteExtendedKalmanFilterHelper::ekfComputeJacobianF(iDynTree::VectorDynSize &,iDynTree::VectorDynSize &,iDynTree::MatrixDynSize &)\n");
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianH(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::MatrixDynSize *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianH",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianH" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianH" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianH" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianH" "', argument " "3"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianH" "', argument " "3"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp3);
  result = (bool)(arg1)->ekfComputeJacobianH(*arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfPredict(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfPredict",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfPredict" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  result = (bool)(arg1)->ekfPredict();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfUpdate(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfUpdate",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfUpdate" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  result = (bool)(arg1)->ekfUpdate();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfInit__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfInit",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfInit" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  result = (bool)(arg1)->ekfInit();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfInit__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  size_t *arg2 = 0 ;
  size_t *arg3 = 0 ;
  size_t *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t temp2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t temp3 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t temp4 ;
  size_t val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfInit",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfInit" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfInit" "', argument " "2"" of type '" "size_t""'");
  } 
  temp2 = static_cast< size_t >(val2);
  arg2 = &temp2;
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfInit" "', argument " "3"" of type '" "size_t""'");
  } 
  temp3 = static_cast< size_t >(val3);
  arg3 = &temp3;
  ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfInit" "', argument " "4"" of type '" "size_t""'");
  } 
  temp4 = static_cast< size_t >(val4);
  arg4 = &temp4;
  result = (bool)(arg1)->ekfInit((size_t const &)*arg2,(size_t const &)*arg3,(size_t const &)*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfInit(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DiscreteExtendedKalmanFilterHelper_ekfInit__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_DiscreteExtendedKalmanFilterHelper_ekfInit__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'DiscreteExtendedKalmanFilterHelper_ekfInit'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::DiscreteExtendedKalmanFilterHelper::ekfInit()\n"
    "    iDynTree::DiscreteExtendedKalmanFilterHelper::ekfInit(size_t const &,size_t const &,size_t const &)\n");
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfReset__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfReset",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfReset" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  (arg1)->ekfReset();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfReset__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  size_t *arg2 = 0 ;
  size_t *arg3 = 0 ;
  size_t *arg4 = 0 ;
  iDynTree::Span< double,-1 > *arg5 = 0 ;
  iDynTree::Span< double,-1 > *arg6 = 0 ;
  iDynTree::Span< double,-1 > *arg7 = 0 ;
  iDynTree::Span< double,-1 > *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t temp2 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t temp3 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t temp4 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfReset",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfReset" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfReset" "', argument " "2"" of type '" "size_t""'");
  } 
  temp2 = static_cast< size_t >(val2);
  arg2 = &temp2;
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfReset" "', argument " "3"" of type '" "size_t""'");
  } 
  temp3 = static_cast< size_t >(val3);
  arg3 = &temp3;
  ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfReset" "', argument " "4"" of type '" "size_t""'");
  } 
  temp4 = static_cast< size_t >(val4);
  arg4 = &temp4;
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfReset" "', argument " "5"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfReset" "', argument " "5"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfReset" "', argument " "6"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfReset" "', argument " "6"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp6);
  res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfReset" "', argument " "7"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfReset" "', argument " "7"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg7 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp7);
  res8 = SWIG_ConvertPtr(argv[7], &argp8, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfReset" "', argument " "8"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfReset" "', argument " "8"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg8 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp8);
  result = (bool)(arg1)->ekfReset((size_t const &)*arg2,(size_t const &)*arg3,(size_t const &)*arg4,(iDynTree::Span< double,-1 > const &)*arg5,(iDynTree::Span< double,-1 > const &)*arg6,(iDynTree::Span< double,-1 > const &)*arg7,(iDynTree::Span< double,-1 > const &)*arg8);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfReset(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DiscreteExtendedKalmanFilterHelper_ekfReset__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_DiscreteExtendedKalmanFilterHelper_ekfReset__SWIG_1(resc,resv,argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'DiscreteExtendedKalmanFilterHelper_ekfReset'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::DiscreteExtendedKalmanFilterHelper::ekfReset()\n"
    "    iDynTree::DiscreteExtendedKalmanFilterHelper::ekfReset(size_t const &,size_t const &,size_t const &,iDynTree::Span< double,-1 > const &,iDynTree::Span< double,-1 > const &,iDynTree::Span< double,-1 > const &,iDynTree::Span< double,-1 > const &)\n");
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfSetMeasurementVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfSetMeasurementVector",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetMeasurementVector" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetMeasurementVector" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetMeasurementVector" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)(arg1)->ekfSetMeasurementVector((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfSetInputVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfSetInputVector",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetInputVector" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetInputVector" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetInputVector" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)(arg1)->ekfSetInputVector((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfSetInitialState(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfSetInitialState",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetInitialState" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetInitialState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetInitialState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)(arg1)->ekfSetInitialState((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfSetStateCovariance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfSetStateCovariance",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetStateCovariance" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetStateCovariance" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetStateCovariance" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)(arg1)->ekfSetStateCovariance((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfSetSystemNoiseCovariance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfSetSystemNoiseCovariance",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetSystemNoiseCovariance" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetSystemNoiseCovariance" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetSystemNoiseCovariance" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)(arg1)->ekfSetSystemNoiseCovariance((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfSetMeasurementNoiseCovariance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfSetMeasurementNoiseCovariance",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetMeasurementNoiseCovariance" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetMeasurementNoiseCovariance" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetMeasurementNoiseCovariance" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)(arg1)->ekfSetMeasurementNoiseCovariance((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfSetStateSize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfSetStateSize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetStateSize" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetStateSize" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->ekfSetStateSize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfSetInputSize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfSetInputSize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetInputSize" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetInputSize" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->ekfSetInputSize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfSetOutputSize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfSetOutputSize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetOutputSize" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfSetOutputSize" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->ekfSetOutputSize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfGetStates(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfGetStates",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfGetStates" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfGetStates" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfGetStates" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)((iDynTree::DiscreteExtendedKalmanFilterHelper const *)arg1)->ekfGetStates((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_DiscreteExtendedKalmanFilterHelper_ekfGetStateCovariance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("DiscreteExtendedKalmanFilterHelper_ekfGetStateCovariance",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfGetStateCovariance" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteExtendedKalmanFilterHelper_ekfGetStateCovariance" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteExtendedKalmanFilterHelper_ekfGetStateCovariance" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)((iDynTree::DiscreteExtendedKalmanFilterHelper const *)arg1)->ekfGetStateCovariance((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_DiscreteExtendedKalmanFilterHelper(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::DiscreteExtendedKalmanFilterHelper *arg1 = (iDynTree::DiscreteExtendedKalmanFilterHelper *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_DiscreteExtendedKalmanFilterHelper",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__DiscreteExtendedKalmanFilterHelper, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscreteExtendedKalmanFilterHelper" "', argument " "1"" of type '" "iDynTree::DiscreteExtendedKalmanFilterHelper *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::DiscreteExtendedKalmanFilterHelper * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


SWIGINTERN int _wrap_output_dimensions_with_magnetometer_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  resv[0] = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(iDynTree::output_dimensions_with_magnetometer));
  return 0;
}


SWIGINTERN int _wrap_output_dimensions_without_magnetometer_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  resv[0] = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(iDynTree::output_dimensions_without_magnetometer));
  return 0;
}


SWIGINTERN int _wrap_input_dimensions_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  resv[0] = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(iDynTree::input_dimensions));
  return 0;
}


int _wrap_AttitudeQuaternionEKFParameters_time_step_in_seconds_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_time_step_in_seconds_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_time_step_in_seconds_set" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKFParameters_time_step_in_seconds_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->time_step_in_seconds = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_time_step_in_seconds_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_time_step_in_seconds_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_time_step_in_seconds_get" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  result = (double) ((arg1)->time_step_in_seconds);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_bias_correlation_time_factor_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_bias_correlation_time_factor_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_bias_correlation_time_factor_set" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKFParameters_bias_correlation_time_factor_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->bias_correlation_time_factor = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_bias_correlation_time_factor_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_bias_correlation_time_factor_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_bias_correlation_time_factor_get" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  result = (double) ((arg1)->bias_correlation_time_factor);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_accelerometer_noise_variance_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_accelerometer_noise_variance_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_accelerometer_noise_variance_set" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKFParameters_accelerometer_noise_variance_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->accelerometer_noise_variance = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_accelerometer_noise_variance_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_accelerometer_noise_variance_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_accelerometer_noise_variance_get" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  result = (double) ((arg1)->accelerometer_noise_variance);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_magnetometer_noise_variance_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_magnetometer_noise_variance_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_magnetometer_noise_variance_set" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKFParameters_magnetometer_noise_variance_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->magnetometer_noise_variance = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_magnetometer_noise_variance_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_magnetometer_noise_variance_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_magnetometer_noise_variance_get" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  result = (double) ((arg1)->magnetometer_noise_variance);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_gyroscope_noise_variance_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_gyroscope_noise_variance_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_gyroscope_noise_variance_set" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKFParameters_gyroscope_noise_variance_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->gyroscope_noise_variance = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_gyroscope_noise_variance_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_gyroscope_noise_variance_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_gyroscope_noise_variance_get" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  result = (double) ((arg1)->gyroscope_noise_variance);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_gyro_bias_noise_variance_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_gyro_bias_noise_variance_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_gyro_bias_noise_variance_set" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKFParameters_gyro_bias_noise_variance_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->gyro_bias_noise_variance = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_gyro_bias_noise_variance_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_gyro_bias_noise_variance_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_gyro_bias_noise_variance_get" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  result = (double) ((arg1)->gyro_bias_noise_variance);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_initial_orientation_error_variance_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_initial_orientation_error_variance_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_initial_orientation_error_variance_set" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKFParameters_initial_orientation_error_variance_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->initial_orientation_error_variance = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_initial_orientation_error_variance_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_initial_orientation_error_variance_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_initial_orientation_error_variance_get" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  result = (double) ((arg1)->initial_orientation_error_variance);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_initial_ang_vel_error_variance_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_initial_ang_vel_error_variance_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_initial_ang_vel_error_variance_set" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKFParameters_initial_ang_vel_error_variance_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->initial_ang_vel_error_variance = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_initial_ang_vel_error_variance_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_initial_ang_vel_error_variance_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_initial_ang_vel_error_variance_get" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  result = (double) ((arg1)->initial_ang_vel_error_variance);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_initial_gyro_bias_error_variance_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_initial_gyro_bias_error_variance_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_initial_gyro_bias_error_variance_set" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKFParameters_initial_gyro_bias_error_variance_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->initial_gyro_bias_error_variance = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_initial_gyro_bias_error_variance_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_initial_gyro_bias_error_variance_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_initial_gyro_bias_error_variance_get" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  result = (double) ((arg1)->initial_gyro_bias_error_variance);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_use_magnetometer_measurements_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_use_magnetometer_measurements_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_use_magnetometer_measurements_set" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKFParameters_use_magnetometer_measurements_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->use_magnetometer_measurements = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKFParameters_use_magnetometer_measurements_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKFParameters_use_magnetometer_measurements_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKFParameters_use_magnetometer_measurements_get" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  result = (bool) ((arg1)->use_magnetometer_measurements);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_AttitudeQuaternionEKFParameters(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::AttitudeQuaternionEKFParameters *result = 0 ;
  
  if (!SWIG_check_num_args("new_AttitudeQuaternionEKFParameters",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::AttitudeQuaternionEKFParameters *)new iDynTree::AttitudeQuaternionEKFParameters();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_AttitudeQuaternionEKFParameters(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKFParameters *arg1 = (iDynTree::AttitudeQuaternionEKFParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_AttitudeQuaternionEKFParameters",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AttitudeQuaternionEKFParameters" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKFParameters *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_AttitudeQuaternionEKF(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::AttitudeQuaternionEKF *result = 0 ;
  
  if (!SWIG_check_num_args("new_AttitudeQuaternionEKF",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::AttitudeQuaternionEKF *)new iDynTree::AttitudeQuaternionEKF();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_getParameters(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  iDynTree::AttitudeQuaternionEKFParameters *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_getParameters",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_getParameters" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeQuaternionEKF_getParameters" "', argument " "2"" of type '" "iDynTree::AttitudeQuaternionEKFParameters &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_getParameters" "', argument " "2"" of type '" "iDynTree::AttitudeQuaternionEKFParameters &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp2);
  (arg1)->getParameters(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_setParameters(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  iDynTree::AttitudeQuaternionEKFParameters *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_setParameters",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_setParameters" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__AttitudeQuaternionEKFParameters,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeQuaternionEKF_setParameters" "', argument " "2"" of type '" "iDynTree::AttitudeQuaternionEKFParameters const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_setParameters" "', argument " "2"" of type '" "iDynTree::AttitudeQuaternionEKFParameters const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::AttitudeQuaternionEKFParameters * >(argp2);
  (arg1)->setParameters((iDynTree::AttitudeQuaternionEKFParameters const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_setGravityDirection(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  iDynTree::Direction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_setGravityDirection",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_setGravityDirection" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeQuaternionEKF_setGravityDirection" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_setGravityDirection" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Direction * >(argp2);
  (arg1)->setGravityDirection((iDynTree::Direction const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_setTimeStepInSeconds(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_setTimeStepInSeconds",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_setTimeStepInSeconds" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKF_setTimeStepInSeconds" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setTimeStepInSeconds(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_setBiasCorrelationTimeFactor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_setBiasCorrelationTimeFactor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_setBiasCorrelationTimeFactor" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKF_setBiasCorrelationTimeFactor" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setBiasCorrelationTimeFactor(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_useMagnetometerMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_useMagnetometerMeasurements",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_useMagnetometerMeasurements" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKF_useMagnetometerMeasurements" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->useMagnetometerMeasurements(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_setMeasurementNoiseVariance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_setMeasurementNoiseVariance",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_setMeasurementNoiseVariance" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKF_setMeasurementNoiseVariance" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AttitudeQuaternionEKF_setMeasurementNoiseVariance" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->setMeasurementNoiseVariance(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_setSystemNoiseVariance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  double arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_setSystemNoiseVariance",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_setSystemNoiseVariance" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKF_setSystemNoiseVariance" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AttitudeQuaternionEKF_setSystemNoiseVariance" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->setSystemNoiseVariance(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_setInitialStateCovariance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_setInitialStateCovariance",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_setInitialStateCovariance" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AttitudeQuaternionEKF_setInitialStateCovariance" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AttitudeQuaternionEKF_setInitialStateCovariance" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AttitudeQuaternionEKF_setInitialStateCovariance" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->setInitialStateCovariance(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_initializeFilter(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_initializeFilter",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_initializeFilter" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  result = (bool)(arg1)->initializeFilter();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_updateFilterWithMeasurements__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  iDynTree::LinearAccelerometerMeasurements *arg2 = 0 ;
  iDynTree::GyroscopeMeasurements *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_updateFilterWithMeasurements",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_updateFilterWithMeasurements" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeQuaternionEKF_updateFilterWithMeasurements" "', argument " "2"" of type '" "iDynTree::LinearAccelerometerMeasurements const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_updateFilterWithMeasurements" "', argument " "2"" of type '" "iDynTree::LinearAccelerometerMeasurements const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinearAccelerometerMeasurements * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AttitudeQuaternionEKF_updateFilterWithMeasurements" "', argument " "3"" of type '" "iDynTree::GyroscopeMeasurements const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_updateFilterWithMeasurements" "', argument " "3"" of type '" "iDynTree::GyroscopeMeasurements const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::GyroscopeMeasurements * >(argp3);
  result = (bool)(arg1)->updateFilterWithMeasurements((iDynTree::LinearAccelerometerMeasurements const &)*arg2,(iDynTree::GyroscopeMeasurements const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_updateFilterWithMeasurements__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  iDynTree::LinearAccelerometerMeasurements *arg2 = 0 ;
  iDynTree::GyroscopeMeasurements *arg3 = 0 ;
  iDynTree::MagnetometerMeasurements *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_updateFilterWithMeasurements",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_updateFilterWithMeasurements" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeQuaternionEKF_updateFilterWithMeasurements" "', argument " "2"" of type '" "iDynTree::LinearAccelerometerMeasurements const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_updateFilterWithMeasurements" "', argument " "2"" of type '" "iDynTree::LinearAccelerometerMeasurements const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinearAccelerometerMeasurements * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AttitudeQuaternionEKF_updateFilterWithMeasurements" "', argument " "3"" of type '" "iDynTree::GyroscopeMeasurements const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_updateFilterWithMeasurements" "', argument " "3"" of type '" "iDynTree::GyroscopeMeasurements const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::GyroscopeMeasurements * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AttitudeQuaternionEKF_updateFilterWithMeasurements" "', argument " "4"" of type '" "iDynTree::MagnetometerMeasurements const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_updateFilterWithMeasurements" "', argument " "4"" of type '" "iDynTree::MagnetometerMeasurements const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::MagnetometerMeasurements * >(argp4);
  result = (bool)(arg1)->updateFilterWithMeasurements((iDynTree::LinearAccelerometerMeasurements const &)*arg2,(iDynTree::GyroscopeMeasurements const &)*arg3,(iDynTree::MagnetometerMeasurements const &)*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_updateFilterWithMeasurements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_AttitudeQuaternionEKF_updateFilterWithMeasurements__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_AttitudeQuaternionEKF_updateFilterWithMeasurements__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'AttitudeQuaternionEKF_updateFilterWithMeasurements'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::AttitudeQuaternionEKF::updateFilterWithMeasurements(iDynTree::LinearAccelerometerMeasurements const &,iDynTree::GyroscopeMeasurements const &)\n"
    "    iDynTree::AttitudeQuaternionEKF::updateFilterWithMeasurements(iDynTree::LinearAccelerometerMeasurements const &,iDynTree::GyroscopeMeasurements const &,iDynTree::MagnetometerMeasurements const &)\n");
  return 1;
}


int _wrap_AttitudeQuaternionEKF_propagateStates(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_propagateStates",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_propagateStates" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  result = (bool)(arg1)->propagateStates();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_getOrientationEstimateAsRotationMatrix(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  iDynTree::Rotation *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_getOrientationEstimateAsRotationMatrix",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_getOrientationEstimateAsRotationMatrix" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeQuaternionEKF_getOrientationEstimateAsRotationMatrix" "', argument " "2"" of type '" "iDynTree::Rotation &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_getOrientationEstimateAsRotationMatrix" "', argument " "2"" of type '" "iDynTree::Rotation &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Rotation * >(argp2);
  result = (bool)(arg1)->getOrientationEstimateAsRotationMatrix(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_getOrientationEstimateAsQuaternion(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  iDynTree::UnitQuaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_getOrientationEstimateAsQuaternion",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_getOrientationEstimateAsQuaternion" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeQuaternionEKF_getOrientationEstimateAsQuaternion" "', argument " "2"" of type '" "iDynTree::UnitQuaternion &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_getOrientationEstimateAsQuaternion" "', argument " "2"" of type '" "iDynTree::UnitQuaternion &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::UnitQuaternion * >(argp2);
  result = (bool)(arg1)->getOrientationEstimateAsQuaternion(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_getOrientationEstimateAsRPY(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  iDynTree::RPY *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_getOrientationEstimateAsRPY",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_getOrientationEstimateAsRPY" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeQuaternionEKF_getOrientationEstimateAsRPY" "', argument " "2"" of type '" "iDynTree::RPY &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_getOrientationEstimateAsRPY" "', argument " "2"" of type '" "iDynTree::RPY &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::RPY * >(argp2);
  result = (bool)(arg1)->getOrientationEstimateAsRPY(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_getInternalStateSize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_getInternalStateSize",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_getInternalStateSize" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  result = ((iDynTree::AttitudeQuaternionEKF const *)arg1)->getInternalStateSize();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_getInternalState(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_getInternalState",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_getInternalState" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeQuaternionEKF_getInternalState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_getInternalState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)((iDynTree::AttitudeQuaternionEKF const *)arg1)->getInternalState((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_getDefaultInternalInitialState(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_getDefaultInternalInitialState",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_getDefaultInternalInitialState" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeQuaternionEKF_getDefaultInternalInitialState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_getDefaultInternalInitialState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)((iDynTree::AttitudeQuaternionEKF const *)arg1)->getDefaultInternalInitialState((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_setInternalState(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_setInternalState",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_setInternalState" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeQuaternionEKF_setInternalState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_setInternalState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)(arg1)->setInternalState((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_AttitudeQuaternionEKF_setInternalStateInitialOrientation(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  iDynTree::Span< double,-1 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("AttitudeQuaternionEKF_setInternalStateInitialOrientation",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AttitudeQuaternionEKF_setInternalStateInitialOrientation" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AttitudeQuaternionEKF_setInternalStateInitialOrientation" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AttitudeQuaternionEKF_setInternalStateInitialOrientation" "', argument " "2"" of type '" "iDynTree::Span< double,-1 > const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2);
  result = (bool)(arg1)->setInternalStateInitialOrientation((iDynTree::Span< double,-1 > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_AttitudeQuaternionEKF(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::AttitudeQuaternionEKF *arg1 = (iDynTree::AttitudeQuaternionEKF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_AttitudeQuaternionEKF",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__AttitudeQuaternionEKF, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AttitudeQuaternionEKF" "', argument " "1"" of type '" "iDynTree::AttitudeQuaternionEKF *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::AttitudeQuaternionEKF * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_estimateInertialParametersFromLinkBoundingBoxesAndTotalMass(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  iDynTree::Model *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("estimateInertialParametersFromLinkBoundingBoxesAndTotalMass",argc,3,3,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "estimateInertialParametersFromLinkBoundingBoxesAndTotalMass" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "estimateInertialParametersFromLinkBoundingBoxesAndTotalMass" "', argument " "2"" of type '" "iDynTree::Model &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateInertialParametersFromLinkBoundingBoxesAndTotalMass" "', argument " "2"" of type '" "iDynTree::Model &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "estimateInertialParametersFromLinkBoundingBoxesAndTotalMass" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "estimateInertialParametersFromLinkBoundingBoxesAndTotalMass" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  result = (bool)iDynTree::estimateInertialParametersFromLinkBoundingBoxesAndTotalMass(arg1,*arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_computeBoundingBoxFromShape(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::SolidShape *arg1 = 0 ;
  iDynTree::Box *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("computeBoundingBoxFromShape",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__SolidShape,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "computeBoundingBoxFromShape" "', argument " "1"" of type '" "iDynTree::SolidShape const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "computeBoundingBoxFromShape" "', argument " "1"" of type '" "iDynTree::SolidShape const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::SolidShape * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Box,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "computeBoundingBoxFromShape" "', argument " "2"" of type '" "iDynTree::Box &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "computeBoundingBoxFromShape" "', argument " "2"" of type '" "iDynTree::Box &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Box * >(argp2);
  result = (bool)iDynTree::computeBoundingBoxFromShape((iDynTree::SolidShape const &)*arg1,*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_computeBoxVertices(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Box arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< std::vector< iDynTree::Position,std::allocator< iDynTree::Position > > > result;
  
  if (!SWIG_check_num_args("computeBoxVertices",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__Box,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "computeBoxVertices" "', argument " "1"" of type '" "iDynTree::Box const""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "computeBoxVertices" "', argument " "1"" of type '" "iDynTree::Box const""'");
    } else {
      arg1 = *(reinterpret_cast< iDynTree::Box * >(argp1));
    }
  }
  result = iDynTree::computeBoxVertices(arg1);
  _out = SWIG_NewPointerObj((new std::vector< iDynTree::Position,std::allocator< iDynTree::Position > >(static_cast< const std::vector< iDynTree::Position,std::allocator< iDynTree::Position > >& >(result))), SWIGTYPE_p_std__vectorT_iDynTree__Position_std__allocatorT_iDynTree__Position_t_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_KinDynComputations(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::KinDynComputations *result = 0 ;
  
  if (!SWIG_check_num_args("new_KinDynComputations",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::KinDynComputations *)new iDynTree::KinDynComputations();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__KinDynComputations, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_KinDynComputations(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_KinDynComputations",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_KinDynComputations" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_loadRobotModel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_loadRobotModel",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_loadRobotModel" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_loadRobotModel" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_loadRobotModel" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)(arg1)->loadRobotModel((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_isValid" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = (bool)((iDynTree::KinDynComputations const *)arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_setFrameVelocityRepresentation(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameVelocityRepresentation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_setFrameVelocityRepresentation",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_setFrameVelocityRepresentation" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_setFrameVelocityRepresentation" "', argument " "2"" of type '" "iDynTree::FrameVelocityRepresentation""'");
  } 
  arg2 = static_cast< iDynTree::FrameVelocityRepresentation >(val2);
  result = (bool)((iDynTree::KinDynComputations const *)arg1)->setFrameVelocityRepresentation(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getFrameVelocityRepresentation(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::FrameVelocityRepresentation result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameVelocityRepresentation",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameVelocityRepresentation" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = (iDynTree::FrameVelocityRepresentation)((iDynTree::KinDynComputations const *)arg1)->getFrameVelocityRepresentation();
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getNrOfDegreesOfFreedom(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("KinDynComputations_getNrOfDegreesOfFreedom",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getNrOfDegreesOfFreedom" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = (unsigned int)((iDynTree::KinDynComputations const *)arg1)->getNrOfDegreesOfFreedom();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getDescriptionOfDegreeOfFreedom(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("KinDynComputations_getDescriptionOfDegreeOfFreedom",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getDescriptionOfDegreeOfFreedom" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getDescriptionOfDegreeOfFreedom" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((iDynTree::KinDynComputations const *)arg1)->getDescriptionOfDegreeOfFreedom(arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getDescriptionOfDegreesOfFreedom(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("KinDynComputations_getDescriptionOfDegreesOfFreedom",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getDescriptionOfDegreesOfFreedom" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = ((iDynTree::KinDynComputations const *)arg1)->getDescriptionOfDegreesOfFreedom();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getNrOfLinks(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("KinDynComputations_getNrOfLinks",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getNrOfLinks" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = (unsigned int)((iDynTree::KinDynComputations const *)arg1)->getNrOfLinks();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getNrOfFrames(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("KinDynComputations_getNrOfFrames",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getNrOfFrames" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = (unsigned int)((iDynTree::KinDynComputations const *)arg1)->getNrOfFrames();
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getFloatingBase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFloatingBase",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFloatingBase" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = ((iDynTree::KinDynComputations const *)arg1)->getFloatingBase();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_setFloatingBase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_setFloatingBase",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_setFloatingBase" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_setFloatingBase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setFloatingBase" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setFloatingBase((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_KinDynComputations_model(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Model *result = 0 ;
  
  if (!SWIG_check_num_args("KinDynComputations_model",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_model" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = (iDynTree::Model *) &((iDynTree::KinDynComputations const *)arg1)->model();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRobotModel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Model *result = 0 ;
  
  if (!SWIG_check_num_args("KinDynComputations_getRobotModel",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRobotModel" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = (iDynTree::Model *) &((iDynTree::KinDynComputations const *)arg1)->getRobotModel();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRelativeJacobianSparsityPattern__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::FrameIndex arg3 ;
  iDynTree::MatrixDynSize *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getRelativeJacobianSparsityPattern",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRelativeJacobianSparsityPattern" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getRelativeJacobianSparsityPattern" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KinDynComputations_getRelativeJacobianSparsityPattern" "', argument " "3"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg3 = static_cast< iDynTree::FrameIndex >(val3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_getRelativeJacobianSparsityPattern" "', argument " "4"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRelativeJacobianSparsityPattern" "', argument " "4"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp4);
  result = (bool)((iDynTree::KinDynComputations const *)arg1)->getRelativeJacobianSparsityPattern(arg2,arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRelativeJacobianSparsityPattern__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::FrameIndex arg3 ;
  iDynTree::MatrixView< double > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getRelativeJacobianSparsityPattern",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRelativeJacobianSparsityPattern" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getRelativeJacobianSparsityPattern" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KinDynComputations_getRelativeJacobianSparsityPattern" "', argument " "3"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg3 = static_cast< iDynTree::FrameIndex >(val3);
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_getRelativeJacobianSparsityPattern" "', argument " "4"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRelativeJacobianSparsityPattern" "', argument " "4"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp4));
    }
  }
  result = (bool)((iDynTree::KinDynComputations const *)arg1)->getRelativeJacobianSparsityPattern(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRelativeJacobianSparsityPattern(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_KinDynComputations_getRelativeJacobianSparsityPattern__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_KinDynComputations_getRelativeJacobianSparsityPattern__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getRelativeJacobianSparsityPattern'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getRelativeJacobianSparsityPattern(iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::MatrixDynSize &) const\n"
    "    iDynTree::KinDynComputations::getRelativeJacobianSparsityPattern(iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::MatrixView< double >) const\n");
  return 1;
}


int _wrap_KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::MatrixDynSize *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern" "', argument " "3"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern" "', argument " "3"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp3);
  result = (bool)((iDynTree::KinDynComputations const *)arg1)->getFrameFreeFloatingJacobianSparsityPattern(arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::MatrixView< double > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern" "', argument " "3"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern" "', argument " "3"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp3));
    }
  }
  result = (bool)((iDynTree::KinDynComputations const *)arg1)->getFrameFreeFloatingJacobianSparsityPattern(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getFrameFreeFloatingJacobianSparsityPattern(iDynTree::FrameIndex const,iDynTree::MatrixDynSize &) const\n"
    "    iDynTree::KinDynComputations::getFrameFreeFloatingJacobianSparsityPattern(iDynTree::FrameIndex const,iDynTree::MatrixView< double >) const\n");
  return 1;
}


int _wrap_KinDynComputations_setJointPos__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_setJointPos",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_setJointPos" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_setJointPos" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setJointPos" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  result = (bool)(arg1)->setJointPos((iDynTree::VectorDynSize const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_setJointPos__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_setJointPos",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_setJointPos" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_setJointPos" "', argument " "2"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setJointPos" "', argument " "2"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp2));
    }
  }
  result = (bool)(arg1)->setJointPos(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_setJointPos(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_setJointPos__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_setJointPos__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_setJointPos'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::setJointPos(iDynTree::VectorDynSize const &)\n"
    "    iDynTree::KinDynComputations::setJointPos(iDynTree::Span< double const,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_setRobotState__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::Twist *arg4 = 0 ;
  iDynTree::VectorDynSize *arg5 = 0 ;
  iDynTree::Vector3 *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_setRobotState",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_setRobotState" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_setRobotState" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_setRobotState" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_setRobotState" "', argument " "4"" of type '" "iDynTree::Twist const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "4"" of type '" "iDynTree::Twist const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Twist * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "KinDynComputations_setRobotState" "', argument " "5"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "5"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::VectorDynSize * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "KinDynComputations_setRobotState" "', argument " "6"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "6"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::Vector3 * >(argp6);
  result = (bool)(arg1)->setRobotState((iDynTree::Transform const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::Twist const &)*arg4,(iDynTree::VectorDynSize const &)*arg5,(iDynTree::Vector3 const &)*arg6);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_setRobotState__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::MatrixView< double const > > arg2 ;
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg3 ;
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg4 ;
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg5 ;
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_setRobotState",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_setRobotState" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_setRobotState" "', argument " "2"" of type '" "iDynTree::MatrixView< double const >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "2"" of type '" "iDynTree::MatrixView< double const >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::MatrixView< double const > * >(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_setRobotState" "', argument " "3"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "3"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp3));
    }
  }
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_setRobotState" "', argument " "4"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "4"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp4));
    }
  }
  {
    res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "KinDynComputations_setRobotState" "', argument " "5"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "5"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg5 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp5));
    }
  }
  {
    res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "KinDynComputations_setRobotState" "', argument " "6"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "6"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg6 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp6));
    }
  }
  result = (bool)(arg1)->setRobotState(arg2,arg3,arg4,arg5,arg6);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_setRobotState__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_setRobotState",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_setRobotState" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_setRobotState" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_setRobotState" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_setRobotState" "', argument " "4"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "4"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Vector3 * >(argp4);
  result = (bool)(arg1)->setRobotState((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::Vector3 const &)*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_setRobotState__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg2 ;
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg3 ;
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_setRobotState",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_setRobotState" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_setRobotState" "', argument " "2"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "2"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_setRobotState" "', argument " "3"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "3"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp3));
    }
  }
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_setRobotState" "', argument " "4"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_setRobotState" "', argument " "4"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp4));
    }
  }
  result = (bool)(arg1)->setRobotState(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_setRobotState(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_KinDynComputations_setRobotState__SWIG_2(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_KinDynComputations_setRobotState__SWIG_3(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Twist, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_KinDynComputations_setRobotState__SWIG_0(resc,resv,argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_const_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_KinDynComputations_setRobotState__SWIG_1(resc,resv,argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_setRobotState'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::setRobotState(iDynTree::Transform const &,iDynTree::VectorDynSize const &,iDynTree::Twist const &,iDynTree::VectorDynSize const &,iDynTree::Vector3 const &)\n"
    "    iDynTree::KinDynComputations::setRobotState(iDynTree::MatrixView< double const >,iDynTree::Span< double const,-1 >,iDynTree::Span< double const,-1 >,iDynTree::Span< double const,-1 >,iDynTree::Span< double const,-1 >)\n"
    "    iDynTree::KinDynComputations::setRobotState(iDynTree::VectorDynSize const &,iDynTree::VectorDynSize const &,iDynTree::Vector3 const &)\n"
    "    iDynTree::KinDynComputations::setRobotState(iDynTree::Span< double const,-1 >,iDynTree::Span< double const,-1 >,iDynTree::Span< double const,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_getRobotState__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::Twist *arg4 = 0 ;
  iDynTree::VectorDynSize *arg5 = 0 ;
  iDynTree::Vector3 *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("KinDynComputations_getRobotState",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRobotState" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getRobotState" "', argument " "2"" of type '" "iDynTree::Transform &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "2"" of type '" "iDynTree::Transform &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getRobotState" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Twist,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_getRobotState" "', argument " "4"" of type '" "iDynTree::Twist &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "4"" of type '" "iDynTree::Twist &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Twist * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "KinDynComputations_getRobotState" "', argument " "5"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "5"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::VectorDynSize * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "KinDynComputations_getRobotState" "', argument " "6"" of type '" "iDynTree::Vector3 &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "6"" of type '" "iDynTree::Vector3 &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::Vector3 * >(argp6);
  (arg1)->getRobotState(*arg2,*arg3,*arg4,*arg5,*arg6);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRobotState__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("KinDynComputations_getRobotState",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRobotState" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getRobotState" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getRobotState" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_getRobotState" "', argument " "4"" of type '" "iDynTree::Vector3 &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "4"" of type '" "iDynTree::Vector3 &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Vector3 * >(argp4);
  (arg1)->getRobotState(*arg2,*arg3,*arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRobotState__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::MatrixView< double > arg2 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg3 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg4 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg5 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getRobotState",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRobotState" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getRobotState" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getRobotState" "', argument " "3"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "3"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp3));
    }
  }
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_getRobotState" "', argument " "4"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "4"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp4));
    }
  }
  {
    res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "KinDynComputations_getRobotState" "', argument " "5"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "5"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg5 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp5));
    }
  }
  {
    res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "KinDynComputations_getRobotState" "', argument " "6"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "6"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg6 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp6));
    }
  }
  result = (bool)(arg1)->getRobotState(arg2,arg3,arg4,arg5,arg6);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRobotState__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg3 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("KinDynComputations_getRobotState",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRobotState" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getRobotState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getRobotState" "', argument " "3"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "3"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp3));
    }
  }
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_getRobotState" "', argument " "4"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRobotState" "', argument " "4"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp4));
    }
  }
  (arg1)->getRobotState(arg2,arg3,arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRobotState(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_KinDynComputations_getRobotState__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_KinDynComputations_getRobotState__SWIG_3(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_KinDynComputations_getRobotState__SWIG_2(resc,resv,argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Twist, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_KinDynComputations_getRobotState__SWIG_0(resc,resv,argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getRobotState'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getRobotState(iDynTree::Transform &,iDynTree::VectorDynSize &,iDynTree::Twist &,iDynTree::VectorDynSize &,iDynTree::Vector3 &)\n"
    "    iDynTree::KinDynComputations::getRobotState(iDynTree::VectorDynSize &,iDynTree::VectorDynSize &,iDynTree::Vector3 &)\n"
    "    iDynTree::KinDynComputations::getRobotState(iDynTree::MatrixView< double >,iDynTree::Span< double,-1 >,iDynTree::Span< double,-1 >,iDynTree::Span< double,-1 >,iDynTree::Span< double,-1 >)\n"
    "    iDynTree::KinDynComputations::getRobotState(iDynTree::Span< double,-1 >,iDynTree::Span< double,-1 >,iDynTree::Span< double,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_getWorldBaseTransform__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("KinDynComputations_getWorldBaseTransform",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getWorldBaseTransform" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = ((iDynTree::KinDynComputations const *)arg1)->getWorldBaseTransform();
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getWorldBaseTransform__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::MatrixView< double > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getWorldBaseTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getWorldBaseTransform" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getWorldBaseTransform" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getWorldBaseTransform" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp2));
    }
  }
  result = (bool)((iDynTree::KinDynComputations const *)arg1)->getWorldBaseTransform(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getWorldBaseTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KinDynComputations_getWorldBaseTransform__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getWorldBaseTransform__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getWorldBaseTransform'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getWorldBaseTransform() const\n"
    "    iDynTree::KinDynComputations::getWorldBaseTransform(iDynTree::MatrixView< double >) const\n");
  return 1;
}


int _wrap_KinDynComputations_getBaseTwist__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("KinDynComputations_getBaseTwist",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getBaseTwist" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = ((iDynTree::KinDynComputations const *)arg1)->getBaseTwist();
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getBaseTwist__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getBaseTwist",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getBaseTwist" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getBaseTwist" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getBaseTwist" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2));
    }
  }
  result = (bool)((iDynTree::KinDynComputations const *)arg1)->getBaseTwist(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getBaseTwist(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KinDynComputations_getBaseTwist__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getBaseTwist__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getBaseTwist'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getBaseTwist() const\n"
    "    iDynTree::KinDynComputations::getBaseTwist(iDynTree::Span< double,-1 >) const\n");
  return 1;
}


int _wrap_KinDynComputations_getJointPos__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getJointPos",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getJointPos" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getJointPos" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getJointPos" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  result = (bool)((iDynTree::KinDynComputations const *)arg1)->getJointPos(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getJointPos__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getJointPos",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getJointPos" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getJointPos" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getJointPos" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2));
    }
  }
  result = (bool)((iDynTree::KinDynComputations const *)arg1)->getJointPos(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getJointPos(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getJointPos__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getJointPos__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getJointPos'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getJointPos(iDynTree::VectorDynSize &) const\n"
    "    iDynTree::KinDynComputations::getJointPos(iDynTree::Span< double,-1 >) const\n");
  return 1;
}


int _wrap_KinDynComputations_getJointVel__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getJointVel",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getJointVel" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getJointVel" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getJointVel" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  result = (bool)((iDynTree::KinDynComputations const *)arg1)->getJointVel(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getJointVel__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getJointVel",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getJointVel" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getJointVel" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getJointVel" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2));
    }
  }
  result = (bool)((iDynTree::KinDynComputations const *)arg1)->getJointVel(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getJointVel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getJointVel__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getJointVel__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getJointVel'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getJointVel(iDynTree::VectorDynSize &) const\n"
    "    iDynTree::KinDynComputations::getJointVel(iDynTree::Span< double,-1 >) const\n");
  return 1;
}


int _wrap_KinDynComputations_getModelVel__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getModelVel",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getModelVel" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getModelVel" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getModelVel" "', argument " "2"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  result = (bool)((iDynTree::KinDynComputations const *)arg1)->getModelVel(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getModelVel__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getModelVel",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getModelVel" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getModelVel" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getModelVel" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2));
    }
  }
  result = (bool)((iDynTree::KinDynComputations const *)arg1)->getModelVel(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getModelVel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getModelVel__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getModelVel__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getModelVel'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getModelVel(iDynTree::VectorDynSize &) const\n"
    "    iDynTree::KinDynComputations::getModelVel(iDynTree::Span< double,-1 >) const\n");
  return 1;
}


int _wrap_KinDynComputations_getFrameIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  int result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameIndex" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getFrameIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameIndex" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (int)((iDynTree::KinDynComputations const *)arg1)->getFrameIndex((std::string const &)*arg2);
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_KinDynComputations_getFrameName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameName" "', argument " "1"" of type '" "iDynTree::KinDynComputations const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getFrameName" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  result = ((iDynTree::KinDynComputations const *)arg1)->getFrameName(arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getWorldTransform__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("KinDynComputations_getWorldTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getWorldTransform" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getWorldTransform" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  result = (arg1)->getWorldTransform(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getWorldTransform__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::MatrixView< double > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getWorldTransform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getWorldTransform" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getWorldTransform" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getWorldTransform" "', argument " "3"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getWorldTransform" "', argument " "3"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp3));
    }
  }
  result = (bool)(arg1)->getWorldTransform(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getWorldTransform__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("KinDynComputations_getWorldTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getWorldTransform" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getWorldTransform" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getWorldTransform" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->getWorldTransform((std::string const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_KinDynComputations_getWorldTransform__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::MatrixView< double > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getWorldTransform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getWorldTransform" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getWorldTransform" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getWorldTransform" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getWorldTransform" "', argument " "3"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getWorldTransform" "', argument " "3"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp3));
    }
  }
  result = (bool)(arg1)->getWorldTransform((std::string const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_KinDynComputations_getWorldTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KinDynComputations_getWorldTransform__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getWorldTransform__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_KinDynComputations_getWorldTransform__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_KinDynComputations_getWorldTransform__SWIG_3(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getWorldTransform'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getWorldTransform(iDynTree::FrameIndex const)\n"
    "    iDynTree::KinDynComputations::getWorldTransform(iDynTree::FrameIndex const,iDynTree::MatrixView< double >)\n"
    "    iDynTree::KinDynComputations::getWorldTransform(std::string const &)\n"
    "    iDynTree::KinDynComputations::getWorldTransform(std::string const &,iDynTree::MatrixView< double >)\n");
  return 1;
}


int _wrap_KinDynComputations_getWorldTransformsAsHomogeneous(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  std::vector< iDynTree::Matrix4x4,std::allocator< iDynTree::Matrix4x4 > > result;
  
  if (!SWIG_check_num_args("KinDynComputations_getWorldTransformsAsHomogeneous",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getWorldTransformsAsHomogeneous" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getWorldTransformsAsHomogeneous" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getWorldTransformsAsHomogeneous" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->getWorldTransformsAsHomogeneous((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
  _out = SWIG_NewPointerObj((new std::vector< iDynTree::Matrix4x4,std::allocator< iDynTree::Matrix4x4 > >(static_cast< const std::vector< iDynTree::Matrix4x4,std::allocator< iDynTree::Matrix4x4 > >& >(result))), SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_KinDynComputations_getRelativeTransform__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::FrameIndex arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("KinDynComputations_getRelativeTransform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRelativeTransform" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getRelativeTransform" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KinDynComputations_getRelativeTransform" "', argument " "3"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg3 = static_cast< iDynTree::FrameIndex >(val3);
  result = (arg1)->getRelativeTransform(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRelativeTransform__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::FrameIndex arg3 ;
  iDynTree::MatrixView< double > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getRelativeTransform",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRelativeTransform" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getRelativeTransform" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KinDynComputations_getRelativeTransform" "', argument " "3"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg3 = static_cast< iDynTree::FrameIndex >(val3);
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_getRelativeTransform" "', argument " "4"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRelativeTransform" "', argument " "4"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp4));
    }
  }
  result = (bool)(arg1)->getRelativeTransform(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRelativeTransformExplicit__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::FrameIndex arg3 ;
  iDynTree::FrameIndex arg4 ;
  iDynTree::FrameIndex arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("KinDynComputations_getRelativeTransformExplicit",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRelativeTransformExplicit" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getRelativeTransformExplicit" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KinDynComputations_getRelativeTransformExplicit" "', argument " "3"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg3 = static_cast< iDynTree::FrameIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "KinDynComputations_getRelativeTransformExplicit" "', argument " "4"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg4 = static_cast< iDynTree::FrameIndex >(val4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "KinDynComputations_getRelativeTransformExplicit" "', argument " "5"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg5 = static_cast< iDynTree::FrameIndex >(val5);
  result = (arg1)->getRelativeTransformExplicit(arg2,arg3,arg4,arg5);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRelativeTransformExplicit__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::FrameIndex arg3 ;
  iDynTree::FrameIndex arg4 ;
  iDynTree::FrameIndex arg5 ;
  iDynTree::MatrixView< double > arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getRelativeTransformExplicit",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRelativeTransformExplicit" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getRelativeTransformExplicit" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KinDynComputations_getRelativeTransformExplicit" "', argument " "3"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg3 = static_cast< iDynTree::FrameIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "KinDynComputations_getRelativeTransformExplicit" "', argument " "4"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg4 = static_cast< iDynTree::FrameIndex >(val4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "KinDynComputations_getRelativeTransformExplicit" "', argument " "5"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg5 = static_cast< iDynTree::FrameIndex >(val5);
  {
    res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "KinDynComputations_getRelativeTransformExplicit" "', argument " "6"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRelativeTransformExplicit" "', argument " "6"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg6 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp6));
    }
  }
  result = (bool)(arg1)->getRelativeTransformExplicit(arg2,arg3,arg4,arg5,arg6);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRelativeTransformExplicit(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_ptrdiff_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_ptrdiff_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_KinDynComputations_getRelativeTransformExplicit__SWIG_0(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_ptrdiff_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_ptrdiff_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_KinDynComputations_getRelativeTransformExplicit__SWIG_1(resc,resv,argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getRelativeTransformExplicit'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getRelativeTransformExplicit(iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::FrameIndex const)\n"
    "    iDynTree::KinDynComputations::getRelativeTransformExplicit(iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::MatrixView< double >)\n");
  return 1;
}


int _wrap_KinDynComputations_getRelativeTransform__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("KinDynComputations_getRelativeTransform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRelativeTransform" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getRelativeTransform" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRelativeTransform" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getRelativeTransform" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRelativeTransform" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (arg1)->getRelativeTransform((std::string const &)*arg2,(std::string const &)*arg3);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_KinDynComputations_getRelativeTransform__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  iDynTree::MatrixView< double > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getRelativeTransform",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRelativeTransform" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getRelativeTransform" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRelativeTransform" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getRelativeTransform" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRelativeTransform" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_getRelativeTransform" "', argument " "4"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRelativeTransform" "', argument " "4"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp4));
    }
  }
  result = (bool)(arg1)->getRelativeTransform((std::string const &)*arg2,(std::string const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_KinDynComputations_getRelativeTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_KinDynComputations_getRelativeTransform__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_KinDynComputations_getRelativeTransform__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_KinDynComputations_getRelativeTransform__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_KinDynComputations_getRelativeTransform__SWIG_3(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getRelativeTransform'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getRelativeTransform(iDynTree::FrameIndex const,iDynTree::FrameIndex const)\n"
    "    iDynTree::KinDynComputations::getRelativeTransform(iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::MatrixView< double >)\n"
    "    iDynTree::KinDynComputations::getRelativeTransform(std::string const &,std::string const &)\n"
    "    iDynTree::KinDynComputations::getRelativeTransform(std::string const &,std::string const &,iDynTree::MatrixView< double >)\n");
  return 1;
}


int _wrap_KinDynComputations_getFrameVel__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameVel",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameVel" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getFrameVel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameVel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->getFrameVel((std::string const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_KinDynComputations_getFrameVel__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::string *arg2 = 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameVel",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameVel" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getFrameVel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameVel" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getFrameVel" "', argument " "3"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameVel" "', argument " "3"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp3));
    }
  }
  result = (bool)(arg1)->getFrameVel((std::string const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_KinDynComputations_getFrameVel__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameVel",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameVel" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getFrameVel" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  result = (arg1)->getFrameVel(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getFrameVel__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameVel",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameVel" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getFrameVel" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getFrameVel" "', argument " "3"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameVel" "', argument " "3"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp3));
    }
  }
  result = (bool)(arg1)->getFrameVel(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getFrameVel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KinDynComputations_getFrameVel__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getFrameVel__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_KinDynComputations_getFrameVel__SWIG_3(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_KinDynComputations_getFrameVel__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getFrameVel'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getFrameVel(std::string const &)\n"
    "    iDynTree::KinDynComputations::getFrameVel(std::string const &,iDynTree::Span< double,-1 >)\n"
    "    iDynTree::KinDynComputations::getFrameVel(iDynTree::FrameIndex const)\n"
    "    iDynTree::KinDynComputations::getFrameVel(iDynTree::FrameIndex const,iDynTree::Span< double,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_getFrameAcc__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Vector6 *arg3 = 0 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  iDynTree::Vector6 result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameAcc",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameAcc" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getFrameAcc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameAcc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getFrameAcc" "', argument " "3"" of type '" "iDynTree::Vector6 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameAcc" "', argument " "3"" of type '" "iDynTree::Vector6 const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Vector6 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_getFrameAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  result = (arg1)->getFrameAcc((std::string const &)*arg2,(iDynTree::Vector6 const &)*arg3,(iDynTree::VectorDynSize const &)*arg4);
  _out = SWIG_NewPointerObj((new iDynTree::Vector6(static_cast< const iDynTree::Vector6& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_KinDynComputations_getFrameAcc__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::string *arg2 = 0 ;
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg3 ;
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg4 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameAcc",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameAcc" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getFrameAcc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameAcc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getFrameAcc" "', argument " "3"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameAcc" "', argument " "3"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp3));
    }
  }
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_getFrameAcc" "', argument " "4"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameAcc" "', argument " "4"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp4));
    }
  }
  {
    res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "KinDynComputations_getFrameAcc" "', argument " "5"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameAcc" "', argument " "5"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg5 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp5));
    }
  }
  result = (bool)(arg1)->getFrameAcc((std::string const &)*arg2,arg3,arg4,arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_KinDynComputations_getFrameAcc__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::Vector6 *arg3 = 0 ;
  iDynTree::VectorDynSize *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  iDynTree::Vector6 result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameAcc",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameAcc" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getFrameAcc" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getFrameAcc" "', argument " "3"" of type '" "iDynTree::Vector6 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameAcc" "', argument " "3"" of type '" "iDynTree::Vector6 const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Vector6 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_getFrameAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameAcc" "', argument " "4"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::VectorDynSize * >(argp4);
  result = (arg1)->getFrameAcc(arg2,(iDynTree::Vector6 const &)*arg3,(iDynTree::VectorDynSize const &)*arg4);
  _out = SWIG_NewPointerObj((new iDynTree::Vector6(static_cast< const iDynTree::Vector6& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getFrameAcc__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg3 ;
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg4 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameAcc",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameAcc" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getFrameAcc" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getFrameAcc" "', argument " "3"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameAcc" "', argument " "3"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp3));
    }
  }
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_getFrameAcc" "', argument " "4"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameAcc" "', argument " "4"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp4));
    }
  }
  {
    res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "KinDynComputations_getFrameAcc" "', argument " "5"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameAcc" "', argument " "5"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg5 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp5));
    }
  }
  result = (bool)(arg1)->getFrameAcc(arg2,arg3,arg4,arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getFrameAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_KinDynComputations_getFrameAcc__SWIG_2(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_KinDynComputations_getFrameAcc__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_KinDynComputations_getFrameAcc__SWIG_3(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_KinDynComputations_getFrameAcc__SWIG_1(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getFrameAcc'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getFrameAcc(std::string const &,iDynTree::Vector6 const &,iDynTree::VectorDynSize const &)\n"
    "    iDynTree::KinDynComputations::getFrameAcc(std::string const &,iDynTree::Span< double const,-1 >,iDynTree::Span< double const,-1 >,iDynTree::Span< double,-1 >)\n"
    "    iDynTree::KinDynComputations::getFrameAcc(iDynTree::FrameIndex const,iDynTree::Vector6 const &,iDynTree::VectorDynSize const &)\n"
    "    iDynTree::KinDynComputations::getFrameAcc(iDynTree::FrameIndex const,iDynTree::Span< double const,-1 >,iDynTree::Span< double const,-1 >,iDynTree::Span< double,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_getFrameFreeFloatingJacobian__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::MatrixDynSize *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameFreeFloatingJacobian",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "3"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "3"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp3);
  result = (bool)(arg1)->getFrameFreeFloatingJacobian((std::string const &)*arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_KinDynComputations_getFrameFreeFloatingJacobian__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::MatrixDynSize *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameFreeFloatingJacobian",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "3"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "3"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp3);
  result = (bool)(arg1)->getFrameFreeFloatingJacobian(arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getFrameFreeFloatingJacobian__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::MatrixView< double > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameFreeFloatingJacobian",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "3"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "3"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp3));
    }
  }
  result = (bool)(arg1)->getFrameFreeFloatingJacobian((std::string const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_KinDynComputations_getFrameFreeFloatingJacobian__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::MatrixView< double > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameFreeFloatingJacobian",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "3"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameFreeFloatingJacobian" "', argument " "3"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp3));
    }
  }
  result = (bool)(arg1)->getFrameFreeFloatingJacobian(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getFrameFreeFloatingJacobian(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_KinDynComputations_getFrameFreeFloatingJacobian__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_KinDynComputations_getFrameFreeFloatingJacobian__SWIG_3(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_KinDynComputations_getFrameFreeFloatingJacobian__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_KinDynComputations_getFrameFreeFloatingJacobian__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getFrameFreeFloatingJacobian'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getFrameFreeFloatingJacobian(std::string const &,iDynTree::MatrixDynSize &)\n"
    "    iDynTree::KinDynComputations::getFrameFreeFloatingJacobian(iDynTree::FrameIndex const,iDynTree::MatrixDynSize &)\n"
    "    iDynTree::KinDynComputations::getFrameFreeFloatingJacobian(std::string const &,iDynTree::MatrixView< double >)\n"
    "    iDynTree::KinDynComputations::getFrameFreeFloatingJacobian(iDynTree::FrameIndex const,iDynTree::MatrixView< double >)\n");
  return 1;
}


int _wrap_KinDynComputations_getRelativeJacobian__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::FrameIndex arg3 ;
  iDynTree::MatrixDynSize *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getRelativeJacobian",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRelativeJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getRelativeJacobian" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KinDynComputations_getRelativeJacobian" "', argument " "3"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg3 = static_cast< iDynTree::FrameIndex >(val3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_getRelativeJacobian" "', argument " "4"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRelativeJacobian" "', argument " "4"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp4);
  result = (bool)(arg1)->getRelativeJacobian(arg2,arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRelativeJacobian__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::FrameIndex arg3 ;
  iDynTree::MatrixView< double > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getRelativeJacobian",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRelativeJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getRelativeJacobian" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KinDynComputations_getRelativeJacobian" "', argument " "3"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg3 = static_cast< iDynTree::FrameIndex >(val3);
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_getRelativeJacobian" "', argument " "4"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRelativeJacobian" "', argument " "4"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp4));
    }
  }
  result = (bool)(arg1)->getRelativeJacobian(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRelativeJacobian(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_KinDynComputations_getRelativeJacobian__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_KinDynComputations_getRelativeJacobian__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getRelativeJacobian'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getRelativeJacobian(iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::MatrixDynSize &)\n"
    "    iDynTree::KinDynComputations::getRelativeJacobian(iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::MatrixView< double >)\n");
  return 1;
}


int _wrap_KinDynComputations_getRelativeJacobianExplicit__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::FrameIndex arg3 ;
  iDynTree::FrameIndex arg4 ;
  iDynTree::FrameIndex arg5 ;
  iDynTree::MatrixDynSize *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getRelativeJacobianExplicit",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRelativeJacobianExplicit" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getRelativeJacobianExplicit" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KinDynComputations_getRelativeJacobianExplicit" "', argument " "3"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg3 = static_cast< iDynTree::FrameIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "KinDynComputations_getRelativeJacobianExplicit" "', argument " "4"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg4 = static_cast< iDynTree::FrameIndex >(val4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "KinDynComputations_getRelativeJacobianExplicit" "', argument " "5"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg5 = static_cast< iDynTree::FrameIndex >(val5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "KinDynComputations_getRelativeJacobianExplicit" "', argument " "6"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRelativeJacobianExplicit" "', argument " "6"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg6 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp6);
  result = (bool)(arg1)->getRelativeJacobianExplicit(arg2,arg3,arg4,arg5,*arg6);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRelativeJacobianExplicit__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  iDynTree::FrameIndex arg3 ;
  iDynTree::FrameIndex arg4 ;
  iDynTree::FrameIndex arg5 ;
  iDynTree::MatrixView< double > arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  ptrdiff_t val4 ;
  int ecode4 = 0 ;
  ptrdiff_t val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getRelativeJacobianExplicit",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getRelativeJacobianExplicit" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getRelativeJacobianExplicit" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "KinDynComputations_getRelativeJacobianExplicit" "', argument " "3"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg3 = static_cast< iDynTree::FrameIndex >(val3);
  ecode4 = SWIG_AsVal_ptrdiff_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "KinDynComputations_getRelativeJacobianExplicit" "', argument " "4"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg4 = static_cast< iDynTree::FrameIndex >(val4);
  ecode5 = SWIG_AsVal_ptrdiff_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "KinDynComputations_getRelativeJacobianExplicit" "', argument " "5"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg5 = static_cast< iDynTree::FrameIndex >(val5);
  {
    res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "KinDynComputations_getRelativeJacobianExplicit" "', argument " "6"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getRelativeJacobianExplicit" "', argument " "6"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg6 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp6));
    }
  }
  result = (bool)(arg1)->getRelativeJacobianExplicit(arg2,arg3,arg4,arg5,arg6);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getRelativeJacobianExplicit(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_ptrdiff_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_ptrdiff_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_KinDynComputations_getRelativeJacobianExplicit__SWIG_0(resc,resv,argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_ptrdiff_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_ptrdiff_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_KinDynComputations_getRelativeJacobianExplicit__SWIG_1(resc,resv,argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getRelativeJacobianExplicit'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getRelativeJacobianExplicit(iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::MatrixDynSize &)\n"
    "    iDynTree::KinDynComputations::getRelativeJacobianExplicit(iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::FrameIndex const,iDynTree::MatrixView< double >)\n");
  return 1;
}


int _wrap_KinDynComputations_getFrameBiasAcc__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Vector6 result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameBiasAcc",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameBiasAcc" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getFrameBiasAcc" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  result = (arg1)->getFrameBiasAcc(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Vector6(static_cast< const iDynTree::Vector6& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getFrameBiasAcc__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FrameIndex arg2 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameBiasAcc",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameBiasAcc" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KinDynComputations_getFrameBiasAcc" "', argument " "2"" of type '" "iDynTree::FrameIndex""'");
  } 
  arg2 = static_cast< iDynTree::FrameIndex >(val2);
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getFrameBiasAcc" "', argument " "3"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameBiasAcc" "', argument " "3"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp3));
    }
  }
  result = (bool)(arg1)->getFrameBiasAcc(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getFrameBiasAcc__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  iDynTree::Vector6 result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameBiasAcc",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameBiasAcc" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getFrameBiasAcc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameBiasAcc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (arg1)->getFrameBiasAcc((std::string const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Vector6(static_cast< const iDynTree::Vector6& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_KinDynComputations_getFrameBiasAcc__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  std::string *arg2 = 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFrameBiasAcc",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFrameBiasAcc" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getFrameBiasAcc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameBiasAcc" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_getFrameBiasAcc" "', argument " "3"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFrameBiasAcc" "', argument " "3"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp3));
    }
  }
  result = (bool)(arg1)->getFrameBiasAcc((std::string const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_KinDynComputations_getFrameBiasAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_KinDynComputations_getFrameBiasAcc__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getFrameBiasAcc__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_KinDynComputations_getFrameBiasAcc__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_KinDynComputations_getFrameBiasAcc__SWIG_3(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getFrameBiasAcc'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getFrameBiasAcc(iDynTree::FrameIndex const)\n"
    "    iDynTree::KinDynComputations::getFrameBiasAcc(iDynTree::FrameIndex const,iDynTree::Span< double,-1 >)\n"
    "    iDynTree::KinDynComputations::getFrameBiasAcc(std::string const &)\n"
    "    iDynTree::KinDynComputations::getFrameBiasAcc(std::string const &,iDynTree::Span< double,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_getCenterOfMassPosition__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCenterOfMassPosition",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCenterOfMassPosition" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = (arg1)->getCenterOfMassPosition();
  _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCenterOfMassPosition__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCenterOfMassPosition",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCenterOfMassPosition" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getCenterOfMassPosition" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getCenterOfMassPosition" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2));
    }
  }
  result = (bool)(arg1)->getCenterOfMassPosition(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCenterOfMassPosition(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KinDynComputations_getCenterOfMassPosition__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getCenterOfMassPosition__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getCenterOfMassPosition'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getCenterOfMassPosition()\n"
    "    iDynTree::KinDynComputations::getCenterOfMassPosition(iDynTree::Span< double,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_getCenterOfMassVelocity__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Vector3 result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCenterOfMassVelocity",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCenterOfMassVelocity" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = (arg1)->getCenterOfMassVelocity();
  _out = SWIG_NewPointerObj((new iDynTree::Vector3(static_cast< const iDynTree::Vector3& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCenterOfMassVelocity__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCenterOfMassVelocity",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCenterOfMassVelocity" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getCenterOfMassVelocity" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getCenterOfMassVelocity" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2));
    }
  }
  result = (bool)(arg1)->getCenterOfMassVelocity(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCenterOfMassVelocity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KinDynComputations_getCenterOfMassVelocity__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getCenterOfMassVelocity__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getCenterOfMassVelocity'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getCenterOfMassVelocity()\n"
    "    iDynTree::KinDynComputations::getCenterOfMassVelocity(iDynTree::Span< double,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_getCenterOfMassJacobian__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::MatrixDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCenterOfMassJacobian",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCenterOfMassJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getCenterOfMassJacobian" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getCenterOfMassJacobian" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp2);
  result = (bool)(arg1)->getCenterOfMassJacobian(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCenterOfMassJacobian__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::MatrixView< double > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCenterOfMassJacobian",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCenterOfMassJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getCenterOfMassJacobian" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getCenterOfMassJacobian" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp2));
    }
  }
  result = (bool)(arg1)->getCenterOfMassJacobian(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCenterOfMassJacobian(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getCenterOfMassJacobian__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getCenterOfMassJacobian__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getCenterOfMassJacobian'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getCenterOfMassJacobian(iDynTree::MatrixDynSize &)\n"
    "    iDynTree::KinDynComputations::getCenterOfMassJacobian(iDynTree::MatrixView< double >)\n");
  return 1;
}


int _wrap_KinDynComputations_getCenterOfMassBiasAcc__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Vector3 result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCenterOfMassBiasAcc",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCenterOfMassBiasAcc" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = (arg1)->getCenterOfMassBiasAcc();
  _out = SWIG_NewPointerObj((new iDynTree::Vector3(static_cast< const iDynTree::Vector3& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCenterOfMassBiasAcc__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCenterOfMassBiasAcc",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCenterOfMassBiasAcc" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getCenterOfMassBiasAcc" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getCenterOfMassBiasAcc" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2));
    }
  }
  result = (bool)(arg1)->getCenterOfMassBiasAcc(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCenterOfMassBiasAcc(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KinDynComputations_getCenterOfMassBiasAcc__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getCenterOfMassBiasAcc__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getCenterOfMassBiasAcc'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getCenterOfMassBiasAcc()\n"
    "    iDynTree::KinDynComputations::getCenterOfMassBiasAcc(iDynTree::Span< double,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_getAverageVelocity__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("KinDynComputations_getAverageVelocity",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getAverageVelocity" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = (arg1)->getAverageVelocity();
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getAverageVelocity__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getAverageVelocity",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getAverageVelocity" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getAverageVelocity" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getAverageVelocity" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2));
    }
  }
  result = (bool)(arg1)->getAverageVelocity(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getAverageVelocity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KinDynComputations_getAverageVelocity__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getAverageVelocity__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getAverageVelocity'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getAverageVelocity()\n"
    "    iDynTree::KinDynComputations::getAverageVelocity(iDynTree::Span< double,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_getAverageVelocityJacobian__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::MatrixDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getAverageVelocityJacobian",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getAverageVelocityJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getAverageVelocityJacobian" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getAverageVelocityJacobian" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp2);
  result = (bool)(arg1)->getAverageVelocityJacobian(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getAverageVelocityJacobian__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::MatrixView< double > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getAverageVelocityJacobian",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getAverageVelocityJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getAverageVelocityJacobian" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getAverageVelocityJacobian" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp2));
    }
  }
  result = (bool)(arg1)->getAverageVelocityJacobian(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getAverageVelocityJacobian(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getAverageVelocityJacobian__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getAverageVelocityJacobian__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getAverageVelocityJacobian'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getAverageVelocityJacobian(iDynTree::MatrixDynSize &)\n"
    "    iDynTree::KinDynComputations::getAverageVelocityJacobian(iDynTree::MatrixView< double >)\n");
  return 1;
}


int _wrap_KinDynComputations_getCentroidalAverageVelocity__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Twist result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCentroidalAverageVelocity",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCentroidalAverageVelocity" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = (arg1)->getCentroidalAverageVelocity();
  _out = SWIG_NewPointerObj((new iDynTree::Twist(static_cast< const iDynTree::Twist& >(result))), SWIGTYPE_p_iDynTree__Twist, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCentroidalAverageVelocity__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCentroidalAverageVelocity",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCentroidalAverageVelocity" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getCentroidalAverageVelocity" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getCentroidalAverageVelocity" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2));
    }
  }
  result = (bool)(arg1)->getCentroidalAverageVelocity(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCentroidalAverageVelocity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KinDynComputations_getCentroidalAverageVelocity__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getCentroidalAverageVelocity__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getCentroidalAverageVelocity'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getCentroidalAverageVelocity()\n"
    "    iDynTree::KinDynComputations::getCentroidalAverageVelocity(iDynTree::Span< double,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_getCentroidalAverageVelocityJacobian__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::MatrixDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCentroidalAverageVelocityJacobian",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCentroidalAverageVelocityJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getCentroidalAverageVelocityJacobian" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getCentroidalAverageVelocityJacobian" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp2);
  result = (bool)(arg1)->getCentroidalAverageVelocityJacobian(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCentroidalAverageVelocityJacobian__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::MatrixView< double > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCentroidalAverageVelocityJacobian",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCentroidalAverageVelocityJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getCentroidalAverageVelocityJacobian" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getCentroidalAverageVelocityJacobian" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp2));
    }
  }
  result = (bool)(arg1)->getCentroidalAverageVelocityJacobian(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCentroidalAverageVelocityJacobian(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getCentroidalAverageVelocityJacobian__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getCentroidalAverageVelocityJacobian__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getCentroidalAverageVelocityJacobian'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getCentroidalAverageVelocityJacobian(iDynTree::MatrixDynSize &)\n"
    "    iDynTree::KinDynComputations::getCentroidalAverageVelocityJacobian(iDynTree::MatrixView< double >)\n");
  return 1;
}


int _wrap_KinDynComputations_getLinearAngularMomentum__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMomentum result;
  
  if (!SWIG_check_num_args("KinDynComputations_getLinearAngularMomentum",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getLinearAngularMomentum" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = (arg1)->getLinearAngularMomentum();
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMomentum(static_cast< const iDynTree::SpatialMomentum& >(result))), SWIGTYPE_p_iDynTree__SpatialMomentum, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getLinearAngularMomentum__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getLinearAngularMomentum",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getLinearAngularMomentum" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getLinearAngularMomentum" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getLinearAngularMomentum" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2));
    }
  }
  result = (bool)(arg1)->getLinearAngularMomentum(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getLinearAngularMomentum(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KinDynComputations_getLinearAngularMomentum__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getLinearAngularMomentum__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getLinearAngularMomentum'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getLinearAngularMomentum()\n"
    "    iDynTree::KinDynComputations::getLinearAngularMomentum(iDynTree::Span< double,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_getLinearAngularMomentumJacobian__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::MatrixDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getLinearAngularMomentumJacobian",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getLinearAngularMomentumJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getLinearAngularMomentumJacobian" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getLinearAngularMomentumJacobian" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp2);
  result = (bool)(arg1)->getLinearAngularMomentumJacobian(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getLinearAngularMomentumJacobian__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::MatrixView< double > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getLinearAngularMomentumJacobian",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getLinearAngularMomentumJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getLinearAngularMomentumJacobian" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getLinearAngularMomentumJacobian" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp2));
    }
  }
  result = (bool)(arg1)->getLinearAngularMomentumJacobian(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getLinearAngularMomentumJacobian(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getLinearAngularMomentumJacobian__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getLinearAngularMomentumJacobian__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getLinearAngularMomentumJacobian'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getLinearAngularMomentumJacobian(iDynTree::MatrixDynSize &)\n"
    "    iDynTree::KinDynComputations::getLinearAngularMomentumJacobian(iDynTree::MatrixView< double >)\n");
  return 1;
}


int _wrap_KinDynComputations_getCentroidalTotalMomentum__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::SpatialMomentum result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCentroidalTotalMomentum",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCentroidalTotalMomentum" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  result = (arg1)->getCentroidalTotalMomentum();
  _out = SWIG_NewPointerObj((new iDynTree::SpatialMomentum(static_cast< const iDynTree::SpatialMomentum& >(result))), SWIGTYPE_p_iDynTree__SpatialMomentum, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCentroidalTotalMomentum__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCentroidalTotalMomentum",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCentroidalTotalMomentum" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getCentroidalTotalMomentum" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getCentroidalTotalMomentum" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2));
    }
  }
  result = (bool)(arg1)->getCentroidalTotalMomentum(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCentroidalTotalMomentum(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_KinDynComputations_getCentroidalTotalMomentum__SWIG_0(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getCentroidalTotalMomentum__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getCentroidalTotalMomentum'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getCentroidalTotalMomentum()\n"
    "    iDynTree::KinDynComputations::getCentroidalTotalMomentum(iDynTree::Span< double,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_getCentroidalTotalMomentumJacobian__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::MatrixDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCentroidalTotalMomentumJacobian",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCentroidalTotalMomentumJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getCentroidalTotalMomentumJacobian" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getCentroidalTotalMomentumJacobian" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp2);
  result = (bool)(arg1)->getCentroidalTotalMomentumJacobian(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCentroidalTotalMomentumJacobian__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::MatrixView< double > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getCentroidalTotalMomentumJacobian",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getCentroidalTotalMomentumJacobian" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getCentroidalTotalMomentumJacobian" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getCentroidalTotalMomentumJacobian" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp2));
    }
  }
  result = (bool)(arg1)->getCentroidalTotalMomentumJacobian(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getCentroidalTotalMomentumJacobian(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getCentroidalTotalMomentumJacobian__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getCentroidalTotalMomentumJacobian__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getCentroidalTotalMomentumJacobian'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getCentroidalTotalMomentumJacobian(iDynTree::MatrixDynSize &)\n"
    "    iDynTree::KinDynComputations::getCentroidalTotalMomentumJacobian(iDynTree::MatrixView< double >)\n");
  return 1;
}


int _wrap_KinDynComputations_getFreeFloatingMassMatrix__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::MatrixDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFreeFloatingMassMatrix",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFreeFloatingMassMatrix" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getFreeFloatingMassMatrix" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFreeFloatingMassMatrix" "', argument " "2"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp2);
  result = (bool)(arg1)->getFreeFloatingMassMatrix(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getFreeFloatingMassMatrix__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::MatrixView< double > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_getFreeFloatingMassMatrix",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_getFreeFloatingMassMatrix" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixViewT_double_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_getFreeFloatingMassMatrix" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_getFreeFloatingMassMatrix" "', argument " "2"" of type '" "iDynTree::MatrixView< double >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::MatrixView< double > * >(argp2));
    }
  }
  result = (bool)(arg1)->getFreeFloatingMassMatrix(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_getFreeFloatingMassMatrix(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getFreeFloatingMassMatrix__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixViewT_double_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_getFreeFloatingMassMatrix__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_getFreeFloatingMassMatrix'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::getFreeFloatingMassMatrix(iDynTree::MatrixDynSize &)\n"
    "    iDynTree::KinDynComputations::getFreeFloatingMassMatrix(iDynTree::MatrixView< double >)\n");
  return 1;
}


int _wrap_KinDynComputations_inverseDynamics__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::Vector6 *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::LinkNetExternalWrenches *arg4 = 0 ;
  iDynTree::FreeFloatingGeneralizedTorques *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_inverseDynamics",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_inverseDynamics" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_inverseDynamics" "', argument " "2"" of type '" "iDynTree::Vector6 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_inverseDynamics" "', argument " "2"" of type '" "iDynTree::Vector6 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector6 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_inverseDynamics" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_inverseDynamics" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_inverseDynamics" "', argument " "4"" of type '" "iDynTree::LinkNetExternalWrenches const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_inverseDynamics" "', argument " "4"" of type '" "iDynTree::LinkNetExternalWrenches const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkNetExternalWrenches * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "KinDynComputations_inverseDynamics" "', argument " "5"" of type '" "iDynTree::FreeFloatingGeneralizedTorques &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_inverseDynamics" "', argument " "5"" of type '" "iDynTree::FreeFloatingGeneralizedTorques &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::FreeFloatingGeneralizedTorques * >(argp5);
  result = (bool)(arg1)->inverseDynamics((iDynTree::Vector6 const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,(iDynTree::LinkNetExternalWrenches const &)*arg4,*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_inverseDynamics__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg2 ;
  SwigValueWrapper< iDynTree::Span< double const,-1 > > arg3 ;
  iDynTree::LinkNetExternalWrenches *arg4 = 0 ;
  iDynTree::FreeFloatingGeneralizedTorques *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_inverseDynamics",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_inverseDynamics" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_inverseDynamics" "', argument " "2"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_inverseDynamics" "', argument " "2"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_inverseDynamics" "', argument " "3"" of type '" "iDynTree::Span< double const,-1 >""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_inverseDynamics" "', argument " "3"" of type '" "iDynTree::Span< double const,-1 >""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::Span< double const,-1 > * >(argp3));
    }
  }
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_inverseDynamics" "', argument " "4"" of type '" "iDynTree::LinkNetExternalWrenches const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_inverseDynamics" "', argument " "4"" of type '" "iDynTree::LinkNetExternalWrenches const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::LinkNetExternalWrenches * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "KinDynComputations_inverseDynamics" "', argument " "5"" of type '" "iDynTree::FreeFloatingGeneralizedTorques &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_inverseDynamics" "', argument " "5"" of type '" "iDynTree::FreeFloatingGeneralizedTorques &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::FreeFloatingGeneralizedTorques * >(argp5);
  result = (bool)(arg1)->inverseDynamics(arg2,arg3,(iDynTree::LinkNetExternalWrenches const &)*arg4,*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_inverseDynamics(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__LinkWrenches, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_KinDynComputations_inverseDynamics__SWIG_0(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__SpanT_double_const__1_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__LinkWrenches, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_KinDynComputations_inverseDynamics__SWIG_1(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_inverseDynamics'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::inverseDynamics(iDynTree::Vector6 const &,iDynTree::VectorDynSize const &,iDynTree::LinkNetExternalWrenches const &,iDynTree::FreeFloatingGeneralizedTorques &)\n"
    "    iDynTree::KinDynComputations::inverseDynamics(iDynTree::Span< double const,-1 >,iDynTree::Span< double const,-1 >,iDynTree::LinkNetExternalWrenches const &,iDynTree::FreeFloatingGeneralizedTorques &)\n");
  return 1;
}


int _wrap_KinDynComputations_generalizedBiasForces__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FreeFloatingGeneralizedTorques *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_generalizedBiasForces",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_generalizedBiasForces" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_generalizedBiasForces" "', argument " "2"" of type '" "iDynTree::FreeFloatingGeneralizedTorques &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_generalizedBiasForces" "', argument " "2"" of type '" "iDynTree::FreeFloatingGeneralizedTorques &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::FreeFloatingGeneralizedTorques * >(argp2);
  result = (bool)(arg1)->generalizedBiasForces(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_generalizedBiasForces__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_generalizedBiasForces",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_generalizedBiasForces" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_generalizedBiasForces" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_generalizedBiasForces" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2));
    }
  }
  result = (bool)(arg1)->generalizedBiasForces(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_generalizedBiasForces(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_generalizedBiasForces__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_generalizedBiasForces__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_generalizedBiasForces'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::generalizedBiasForces(iDynTree::FreeFloatingGeneralizedTorques &)\n"
    "    iDynTree::KinDynComputations::generalizedBiasForces(iDynTree::Span< double,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_generalizedGravityForces__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::FreeFloatingGeneralizedTorques *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_generalizedGravityForces",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_generalizedGravityForces" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_generalizedGravityForces" "', argument " "2"" of type '" "iDynTree::FreeFloatingGeneralizedTorques &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_generalizedGravityForces" "', argument " "2"" of type '" "iDynTree::FreeFloatingGeneralizedTorques &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::FreeFloatingGeneralizedTorques * >(argp2);
  result = (bool)(arg1)->generalizedGravityForces(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_generalizedGravityForces__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  SwigValueWrapper< iDynTree::Span< double,-1 > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_generalizedGravityForces",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_generalizedGravityForces" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__SpanT_double__1_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_generalizedGravityForces" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_generalizedGravityForces" "', argument " "2"" of type '" "iDynTree::Span< double,-1 >""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Span< double,-1 > * >(argp2));
    }
  }
  result = (bool)(arg1)->generalizedGravityForces(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_generalizedGravityForces(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_generalizedGravityForces__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__KinDynComputations, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__SpanT_double__1_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_KinDynComputations_generalizedGravityForces__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'KinDynComputations_generalizedGravityForces'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::KinDynComputations::generalizedGravityForces(iDynTree::FreeFloatingGeneralizedTorques &)\n"
    "    iDynTree::KinDynComputations::generalizedGravityForces(iDynTree::Span< double,-1 >)\n");
  return 1;
}


int _wrap_KinDynComputations_generalizedExternalForces(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::LinkNetExternalWrenches *arg2 = 0 ;
  iDynTree::FreeFloatingGeneralizedTorques *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_generalizedExternalForces",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_generalizedExternalForces" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__LinkWrenches,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_generalizedExternalForces" "', argument " "2"" of type '" "iDynTree::LinkNetExternalWrenches const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_generalizedExternalForces" "', argument " "2"" of type '" "iDynTree::LinkNetExternalWrenches const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkNetExternalWrenches * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__FreeFloatingGeneralizedTorques,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_generalizedExternalForces" "', argument " "3"" of type '" "iDynTree::FreeFloatingGeneralizedTorques &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_generalizedExternalForces" "', argument " "3"" of type '" "iDynTree::FreeFloatingGeneralizedTorques &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::FreeFloatingGeneralizedTorques * >(argp3);
  result = (bool)(arg1)->generalizedExternalForces((iDynTree::LinkNetExternalWrenches const &)*arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_KinDynComputations_inverseDynamicsInertialParametersRegressor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::KinDynComputations *arg1 = (iDynTree::KinDynComputations *) 0 ;
  iDynTree::Vector6 *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  iDynTree::MatrixDynSize *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("KinDynComputations_inverseDynamicsInertialParametersRegressor",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__KinDynComputations, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KinDynComputations_inverseDynamicsInertialParametersRegressor" "', argument " "1"" of type '" "iDynTree::KinDynComputations *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::KinDynComputations * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_6_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KinDynComputations_inverseDynamicsInertialParametersRegressor" "', argument " "2"" of type '" "iDynTree::Vector6 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_inverseDynamicsInertialParametersRegressor" "', argument " "2"" of type '" "iDynTree::Vector6 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector6 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "KinDynComputations_inverseDynamicsInertialParametersRegressor" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_inverseDynamicsInertialParametersRegressor" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__MatrixDynSize,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "KinDynComputations_inverseDynamicsInertialParametersRegressor" "', argument " "4"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KinDynComputations_inverseDynamicsInertialParametersRegressor" "', argument " "4"" of type '" "iDynTree::MatrixDynSize &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp4);
  result = (bool)(arg1)->inverseDynamicsInertialParametersRegressor((iDynTree::Vector6 const &)*arg2,(iDynTree::VectorDynSize const &)*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_pop(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type result;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_pop",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_pop" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  try {
    result = std_vector_Sl_iDynTree_Matrix4x4_Sg__pop(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = SWIG_NewPointerObj((new std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type(static_cast< const std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_brace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type result;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_brace",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_brace" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix4x4Vector_brace" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::difference_type >(val2);
  try {
    result = std_vector_Sl_iDynTree_Matrix4x4_Sg__brace(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = SWIG_NewPointerObj((new std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type(static_cast< const std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type& >(result))), SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_setbrace(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type arg2 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_setbrace",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_setbrace" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix4x4Vector_setbrace" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Matrix4x4Vector_setbrace" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type""'");
    } else {
      arg2 = *(reinterpret_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type * >(argp2));
    }
  }
  ecode3 = SWIG_AsVal_ptrdiff_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix4x4Vector_setbrace" "', argument " "3"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::difference_type >(val3);
  try {
    std_vector_Sl_iDynTree_Matrix4x4_Sg__setbrace(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
  }
  
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_append(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_append",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_append" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix4x4Vector_append" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Matrix4x4Vector_append" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type""'");
    } else {
      arg2 = *(reinterpret_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type * >(argp2));
    }
  }
  std_vector_Sl_iDynTree_Matrix4x4_Sg__append(arg1,arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix4x4Vector__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  std::vector< iDynTree::Matrix4x4 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix4x4Vector",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (std::vector< iDynTree::Matrix4x4 > *)new std::vector< iDynTree::Matrix4x4 >();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix4x4Vector__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  mxArray * _out;
  std::vector< iDynTree::Matrix4x4 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix4x4Vector",argc,1,1,0)) {
    SWIG_fail;
  }
  {
    std::vector< iDynTree::MatrixFixSize< 4,4 >,std::allocator< iDynTree::MatrixFixSize< 4,4 > > > *ptr = (std::vector< iDynTree::MatrixFixSize< 4,4 >,std::allocator< iDynTree::MatrixFixSize< 4,4 > > > *)0;
    res1 = swig::asptr(argv[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Matrix4x4Vector" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Matrix4x4Vector" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > const &""'"); 
    }
    arg1 = ptr;
  }
  result = (std::vector< iDynTree::Matrix4x4 > *)new std::vector< iDynTree::Matrix4x4 >((std::vector< iDynTree::Matrix4x4 > const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 0;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return 1;
}


int _wrap_Matrix4x4Vector_empty(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_empty",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_empty" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  result = (bool)((std::vector< iDynTree::Matrix4x4 > const *)arg1)->empty();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_size(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type result;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_size",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_size" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  result = ((std::vector< iDynTree::Matrix4x4 > const *)arg1)->size();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_swap(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  std::vector< iDynTree::Matrix4x4 > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_swap",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_swap" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix4x4Vector_swap" "', argument " "2"" of type '" "std::vector< iDynTree::Matrix4x4 > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Matrix4x4Vector_swap" "', argument " "2"" of type '" "std::vector< iDynTree::Matrix4x4 > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp2);
  (arg1)->swap(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_begin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > result;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_begin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_begin" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  result = (arg1)->begin();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_end(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > result;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_end",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_end" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  result = (arg1)->end();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_rbegin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< std::vector< iDynTree::MatrixFixSize< 4,4 > >::reverse_iterator > result;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_rbegin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_rbegin" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  result = (arg1)->rbegin();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::MatrixFixSize< 4,4 > >::reverse_iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_rend(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< std::vector< iDynTree::MatrixFixSize< 4,4 > >::reverse_iterator > result;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_rend",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_rend" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  result = (arg1)->rend();
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::MatrixFixSize< 4,4 > >::reverse_iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_clear(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_clear",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_clear" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  (arg1)->clear();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_get_allocator(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  SwigValueWrapper< std::allocator< iDynTree::MatrixFixSize< 4,4 > > > result;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_get_allocator",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_get_allocator" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  result = ((std::vector< iDynTree::Matrix4x4 > const *)arg1)->get_allocator();
  _out = SWIG_NewPointerObj((new std::vector< iDynTree::MatrixFixSize< 4,4 > >::allocator_type(static_cast< const std::vector< iDynTree::MatrixFixSize< 4,4 > >::allocator_type& >(result))), SWIGTYPE_p_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix4x4Vector__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::Matrix4x4 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix4x4Vector",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Matrix4x4Vector" "', argument " "1"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type >(val1);
  result = (std::vector< iDynTree::Matrix4x4 > *)new std::vector< iDynTree::Matrix4x4 >(arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_pop_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_pop_back",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_pop_back" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  (arg1)->pop_back();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_resize__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_resize",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_resize" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix4x4Vector_resize" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type >(val2);
  (arg1)->resize(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_erase__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  SwigValueWrapper< std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  mxArray * _out;
  SwigValueWrapper< std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > result;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_erase",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_erase" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Matrix4x4Vector_erase" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Matrix4x4Vector_erase" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator""'");
    }
  }
  result = std_vector_Sl_iDynTree_Matrix4x4_Sg__erase__SWIG_0(arg1,arg2);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_erase__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  SwigValueWrapper< std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > arg2 ;
  SwigValueWrapper< std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  swig::MatlabSwigIterator *iter3 = 0 ;
  int res3 ;
  mxArray * _out;
  SwigValueWrapper< std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > result;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_erase",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_erase" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Matrix4x4Vector_erase" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Matrix4x4Vector_erase" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter3), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Matrix4x4Vector_erase" "', argument " "3"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Matrix4x4Vector_erase" "', argument " "3"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator""'");
    }
  }
  result = std_vector_Sl_iDynTree_Matrix4x4_Sg__erase__SWIG_1(arg1,arg2,arg3);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_erase(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::MatrixFixSize< 4,4 >,std::allocator< iDynTree::MatrixFixSize< 4,4 > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_Matrix4x4Vector_erase__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::MatrixFixSize< 4,4 >,std::allocator< iDynTree::MatrixFixSize< 4,4 > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::MatlabSwigIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_Matrix4x4Vector_erase__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Matrix4x4Vector_erase'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::Matrix4x4 >::erase(std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator)\n"
    "    std::vector< iDynTree::Matrix4x4 >::erase(std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator,std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator)\n");
  return 1;
}


int _wrap_new_Matrix4x4Vector__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type arg1 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::Matrix4x4 > *result = 0 ;
  
  if (!SWIG_check_num_args("new_Matrix4x4Vector",argc,2,2,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Matrix4x4Vector" "', argument " "1"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Matrix4x4Vector" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Matrix4x4Vector" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type * >(argp2);
  result = (std::vector< iDynTree::Matrix4x4 > *)new std::vector< iDynTree::Matrix4x4 >(arg1,(std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Matrix4x4Vector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_Matrix4x4Vector__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Matrix4x4Vector__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::MatrixFixSize< 4,4 >,std::allocator< iDynTree::MatrixFixSize< 4,4 > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Matrix4x4Vector__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Matrix4x4Vector__SWIG_3(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_Matrix4x4Vector'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::Matrix4x4 >::vector()\n"
    "    std::vector< iDynTree::Matrix4x4 >::vector(std::vector< iDynTree::Matrix4x4 > const &)\n"
    "    std::vector< iDynTree::Matrix4x4 >::vector(std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type)\n"
    "    std::vector< iDynTree::Matrix4x4 >::vector(std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type,std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &)\n");
  return 1;
}


int _wrap_Matrix4x4Vector_push_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_push_back",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_push_back" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix4x4Vector_push_back" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Matrix4x4Vector_push_back" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type * >(argp2);
  (arg1)->push_back((std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_front(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_front",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_front" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  result = (std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type *) &((std::vector< iDynTree::Matrix4x4 > const *)arg1)->front();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_back(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_back",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_back" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  result = (std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type *) &((std::vector< iDynTree::Matrix4x4 > const *)arg1)->back();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_assign(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type arg2 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_assign",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_assign" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix4x4Vector_assign" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Matrix4x4Vector_assign" "', argument " "3"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Matrix4x4Vector_assign" "', argument " "3"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type * >(argp3);
  (arg1)->assign(arg2,(std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_resize__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type arg2 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_resize",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_resize" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix4x4Vector_resize" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Matrix4x4Vector_resize" "', argument " "3"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Matrix4x4Vector_resize" "', argument " "3"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type * >(argp3);
  (arg1)->resize(arg2,(std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &)*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_resize(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::MatrixFixSize< 4,4 >,std::allocator< iDynTree::MatrixFixSize< 4,4 > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Matrix4x4Vector_resize__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::MatrixFixSize< 4,4 >,std::allocator< iDynTree::MatrixFixSize< 4,4 > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Matrix4x4Vector_resize__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Matrix4x4Vector_resize'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::Matrix4x4 >::resize(std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type)\n"
    "    std::vector< iDynTree::Matrix4x4 >::resize(std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type,std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &)\n");
  return 1;
}


int _wrap_Matrix4x4Vector_insert__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  SwigValueWrapper< std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > arg2 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  SwigValueWrapper< std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > result;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_insert",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_insert" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Matrix4x4Vector_insert" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Matrix4x4Vector_insert" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Matrix4x4Vector_insert" "', argument " "3"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Matrix4x4Vector_insert" "', argument " "3"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type * >(argp3);
  result = std_vector_Sl_iDynTree_Matrix4x4_Sg__insert__SWIG_0(arg1,arg2,(iDynTree::MatrixFixSize< 4,4 > const &)*arg3);
  _out = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator & >(result)),
    swig::MatlabSwigIterator::descriptor(),SWIG_POINTER_OWN);
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_insert__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  SwigValueWrapper< std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > arg2 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type arg3 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::MatlabSwigIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_insert",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_insert" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter2), swig::MatlabSwigIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Matrix4x4Vector_insert" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator""'");
  } else {
    swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *iter_t = dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "Matrix4x4Vector_insert" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Matrix4x4Vector_insert" "', argument " "3"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type >(val3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Matrix4x4Vector_insert" "', argument " "4"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Matrix4x4Vector_insert" "', argument " "4"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type * >(argp4);
  std_vector_Sl_iDynTree_Matrix4x4_Sg__insert__SWIG_1(arg1,arg2,arg3,(iDynTree::MatrixFixSize< 4,4 > const &)*arg4);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_insert(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::MatrixFixSize< 4,4 >,std::allocator< iDynTree::MatrixFixSize< 4,4 > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *>(iter) != 0));
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Matrix4x4Vector_insert__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = swig::asptr(argv[0], (std::vector< iDynTree::MatrixFixSize< 4,4 >,std::allocator< iDynTree::MatrixFixSize< 4,4 > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::MatlabSwigIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::MatlabSwigIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::MatlabSwigIterator_T<std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__MatrixFixSizeT_4_4_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Matrix4x4Vector_insert__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Matrix4x4Vector_insert'."
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< iDynTree::Matrix4x4 >::insert(std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator,std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &)\n"
    "    std::vector< iDynTree::Matrix4x4 >::insert(std::vector< iDynTree::MatrixFixSize< 4,4 > >::iterator,std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type,std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type const &)\n");
  return 1;
}


int _wrap_Matrix4x4Vector_reserve(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_reserve",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_reserve" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Matrix4x4Vector_reserve" "', argument " "2"" of type '" "std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type >(val2);
  (arg1)->reserve(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_capacity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::MatrixFixSize< 4,4 > >::size_type result;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_capacity",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_capacity" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  result = ((std::vector< iDynTree::Matrix4x4 > const *)arg1)->capacity();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Matrix4x4Vector_toMatlab(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  mxArray *result = 0 ;
  
  if (!SWIG_check_num_args("Matrix4x4Vector_toMatlab",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix4x4Vector_toMatlab" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  result = (mxArray *)std_vector_Sl_iDynTree_Matrix4x4_Sg__toMatlab((std::vector< iDynTree::MatrixFixSize< 4,4 > > const *)arg1);
  _out = result;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Matrix4x4Vector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  std::vector< iDynTree::Matrix4x4 > *arg1 = (std::vector< iDynTree::Matrix4x4 > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Matrix4x4Vector",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Matrix4x4Vector" "', argument " "1"" of type '" "std::vector< iDynTree::Matrix4x4 > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< iDynTree::Matrix4x4 > * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ICameraAnimator_enableMouseControl__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICameraAnimator *arg1 = (iDynTree::ICameraAnimator *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ICameraAnimator_enableMouseControl",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICameraAnimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ICameraAnimator_enableMouseControl" "', argument " "1"" of type '" "iDynTree::ICameraAnimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICameraAnimator * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ICameraAnimator_enableMouseControl" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->enableMouseControl(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ICameraAnimator_enableMouseControl__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICameraAnimator *arg1 = (iDynTree::ICameraAnimator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ICameraAnimator_enableMouseControl",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICameraAnimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ICameraAnimator_enableMouseControl" "', argument " "1"" of type '" "iDynTree::ICameraAnimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICameraAnimator * >(argp1);
  (arg1)->enableMouseControl();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ICameraAnimator_enableMouseControl(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ICameraAnimator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ICameraAnimator_enableMouseControl__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ICameraAnimator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ICameraAnimator_enableMouseControl__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ICameraAnimator_enableMouseControl'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ICameraAnimator::enableMouseControl(bool)\n"
    "    iDynTree::ICameraAnimator::enableMouseControl()\n");
  return 1;
}


int _wrap_ICameraAnimator_getMoveSpeed(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICameraAnimator *arg1 = (iDynTree::ICameraAnimator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("ICameraAnimator_getMoveSpeed",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICameraAnimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ICameraAnimator_getMoveSpeed" "', argument " "1"" of type '" "iDynTree::ICameraAnimator const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICameraAnimator * >(argp1);
  result = (double)((iDynTree::ICameraAnimator const *)arg1)->getMoveSpeed();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ICameraAnimator_setMoveSpeed(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICameraAnimator *arg1 = (iDynTree::ICameraAnimator *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ICameraAnimator_setMoveSpeed",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICameraAnimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ICameraAnimator_setMoveSpeed" "', argument " "1"" of type '" "iDynTree::ICameraAnimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICameraAnimator * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ICameraAnimator_setMoveSpeed" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setMoveSpeed(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ICameraAnimator_getRotateSpeed(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICameraAnimator *arg1 = (iDynTree::ICameraAnimator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("ICameraAnimator_getRotateSpeed",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICameraAnimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ICameraAnimator_getRotateSpeed" "', argument " "1"" of type '" "iDynTree::ICameraAnimator const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICameraAnimator * >(argp1);
  result = (double)((iDynTree::ICameraAnimator const *)arg1)->getRotateSpeed();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ICameraAnimator_setRotateSpeed(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICameraAnimator *arg1 = (iDynTree::ICameraAnimator *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ICameraAnimator_setRotateSpeed",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICameraAnimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ICameraAnimator_setRotateSpeed" "', argument " "1"" of type '" "iDynTree::ICameraAnimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICameraAnimator * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ICameraAnimator_setRotateSpeed" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setRotateSpeed(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ICameraAnimator_getZoomSpeed(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICameraAnimator *arg1 = (iDynTree::ICameraAnimator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("ICameraAnimator_getZoomSpeed",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICameraAnimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ICameraAnimator_getZoomSpeed" "', argument " "1"" of type '" "iDynTree::ICameraAnimator const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICameraAnimator * >(argp1);
  result = (double)((iDynTree::ICameraAnimator const *)arg1)->getZoomSpeed();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ICameraAnimator_setZoomSpeed(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICameraAnimator *arg1 = (iDynTree::ICameraAnimator *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ICameraAnimator_setZoomSpeed",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICameraAnimator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ICameraAnimator_setZoomSpeed" "', argument " "1"" of type '" "iDynTree::ICameraAnimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICameraAnimator * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ICameraAnimator_setZoomSpeed" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setZoomSpeed(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ICameraAnimator(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICameraAnimator *arg1 = (iDynTree::ICameraAnimator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ICameraAnimator",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICameraAnimator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ICameraAnimator" "', argument " "1"" of type '" "iDynTree::ICameraAnimator *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICameraAnimator * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ICamera(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICamera *arg1 = (iDynTree::ICamera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ICamera",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICamera, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ICamera" "', argument " "1"" of type '" "iDynTree::ICamera *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICamera * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ICamera_setPosition(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICamera *arg1 = (iDynTree::ICamera *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ICamera_setPosition",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ICamera_setPosition" "', argument " "1"" of type '" "iDynTree::ICamera *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICamera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ICamera_setPosition" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ICamera_setPosition" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  (arg1)->setPosition((iDynTree::Position const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ICamera_setTarget(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICamera *arg1 = (iDynTree::ICamera *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ICamera_setTarget",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ICamera_setTarget" "', argument " "1"" of type '" "iDynTree::ICamera *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICamera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ICamera_setTarget" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ICamera_setTarget" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  (arg1)->setTarget((iDynTree::Position const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ICamera_getPosition(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICamera *arg1 = (iDynTree::ICamera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position result;
  
  if (!SWIG_check_num_args("ICamera_getPosition",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ICamera_getPosition" "', argument " "1"" of type '" "iDynTree::ICamera *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICamera * >(argp1);
  result = (arg1)->getPosition();
  _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ICamera_getTarget(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICamera *arg1 = (iDynTree::ICamera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position result;
  
  if (!SWIG_check_num_args("ICamera_getTarget",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ICamera_getTarget" "', argument " "1"" of type '" "iDynTree::ICamera *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICamera * >(argp1);
  result = (arg1)->getTarget();
  _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ICamera_setUpVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICamera *arg1 = (iDynTree::ICamera *) 0 ;
  iDynTree::Direction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ICamera_setUpVector",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ICamera_setUpVector" "', argument " "1"" of type '" "iDynTree::ICamera *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICamera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ICamera_setUpVector" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ICamera_setUpVector" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Direction * >(argp2);
  (arg1)->setUpVector((iDynTree::Direction const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ICamera_animator(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ICamera *arg1 = (iDynTree::ICamera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ICameraAnimator *result = 0 ;
  
  if (!SWIG_check_num_args("ICamera_animator",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ICamera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ICamera_animator" "', argument " "1"" of type '" "iDynTree::ICamera *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ICamera * >(argp1);
  result = (iDynTree::ICameraAnimator *)(arg1)->animator();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ICameraAnimator, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ColorViz_r_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ColorViz *arg1 = (iDynTree::ColorViz *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ColorViz_r_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ColorViz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorViz_r_set" "', argument " "1"" of type '" "iDynTree::ColorViz *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ColorViz * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorViz_r_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->r = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ColorViz_r_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ColorViz *arg1 = (iDynTree::ColorViz *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  float result;
  
  if (!SWIG_check_num_args("ColorViz_r_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ColorViz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorViz_r_get" "', argument " "1"" of type '" "iDynTree::ColorViz *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ColorViz * >(argp1);
  result = (float) ((arg1)->r);
  _out = SWIG_From_float(static_cast< float >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ColorViz_g_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ColorViz *arg1 = (iDynTree::ColorViz *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ColorViz_g_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ColorViz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorViz_g_set" "', argument " "1"" of type '" "iDynTree::ColorViz *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ColorViz * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorViz_g_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->g = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ColorViz_g_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ColorViz *arg1 = (iDynTree::ColorViz *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  float result;
  
  if (!SWIG_check_num_args("ColorViz_g_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ColorViz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorViz_g_get" "', argument " "1"" of type '" "iDynTree::ColorViz *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ColorViz * >(argp1);
  result = (float) ((arg1)->g);
  _out = SWIG_From_float(static_cast< float >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ColorViz_b_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ColorViz *arg1 = (iDynTree::ColorViz *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ColorViz_b_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ColorViz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorViz_b_set" "', argument " "1"" of type '" "iDynTree::ColorViz *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ColorViz * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorViz_b_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->b = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ColorViz_b_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ColorViz *arg1 = (iDynTree::ColorViz *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  float result;
  
  if (!SWIG_check_num_args("ColorViz_b_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ColorViz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorViz_b_get" "', argument " "1"" of type '" "iDynTree::ColorViz *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ColorViz * >(argp1);
  result = (float) ((arg1)->b);
  _out = SWIG_From_float(static_cast< float >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ColorViz_a_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ColorViz *arg1 = (iDynTree::ColorViz *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ColorViz_a_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ColorViz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorViz_a_set" "', argument " "1"" of type '" "iDynTree::ColorViz *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ColorViz * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ColorViz_a_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->a = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ColorViz_a_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ColorViz *arg1 = (iDynTree::ColorViz *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  float result;
  
  if (!SWIG_check_num_args("ColorViz_a_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ColorViz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ColorViz_a_get" "', argument " "1"" of type '" "iDynTree::ColorViz *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ColorViz * >(argp1);
  result = (float) ((arg1)->a);
  _out = SWIG_From_float(static_cast< float >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ColorViz__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ColorViz *result = 0 ;
  
  if (!SWIG_check_num_args("new_ColorViz",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ColorViz *)new iDynTree::ColorViz();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ColorViz, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ColorViz__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  iDynTree::ColorViz *result = 0 ;
  
  if (!SWIG_check_num_args("new_ColorViz",argc,4,4,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ColorViz" "', argument " "1"" of type '" "float""'");
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ColorViz" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ColorViz" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ColorViz" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  result = (iDynTree::ColorViz *)new iDynTree::ColorViz(arg1,arg2,arg3,arg4);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ColorViz, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ColorViz__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Vector4 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ColorViz *result = 0 ;
  
  if (!SWIG_check_num_args("new_ColorViz",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ColorViz" "', argument " "1"" of type '" "iDynTree::Vector4 const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ColorViz" "', argument " "1"" of type '" "iDynTree::Vector4 const &""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Vector4 * >(argp1);
  result = (iDynTree::ColorViz *)new iDynTree::ColorViz((iDynTree::Vector4 const &)*arg1);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ColorViz, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ColorViz(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 0) {
    return _wrap_new_ColorViz__SWIG_0(resc,resv,argc,argv);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_4_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ColorViz__SWIG_2(resc,resv,argc,argv);
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_ColorViz__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'new_ColorViz'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ColorViz::ColorViz()\n"
    "    iDynTree::ColorViz::ColorViz(float,float,float,float)\n"
    "    iDynTree::ColorViz::ColorViz(iDynTree::Vector4 const &)\n");
  return 1;
}


int _wrap_delete_ColorViz(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ColorViz *arg1 = (iDynTree::ColorViz *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ColorViz",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ColorViz, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ColorViz" "', argument " "1"" of type '" "iDynTree::ColorViz *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ColorViz * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PixelViz_width_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PixelViz *arg1 = (iDynTree::PixelViz *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("PixelViz_width_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PixelViz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelViz_width_set" "', argument " "1"" of type '" "iDynTree::PixelViz *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PixelViz * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelViz_width_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->width = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PixelViz_width_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PixelViz *arg1 = (iDynTree::PixelViz *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("PixelViz_width_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PixelViz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelViz_width_get" "', argument " "1"" of type '" "iDynTree::PixelViz *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PixelViz * >(argp1);
  result = (unsigned int) ((arg1)->width);
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PixelViz_height_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PixelViz *arg1 = (iDynTree::PixelViz *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("PixelViz_height_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PixelViz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelViz_height_set" "', argument " "1"" of type '" "iDynTree::PixelViz *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PixelViz * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PixelViz_height_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->height = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_PixelViz_height_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PixelViz *arg1 = (iDynTree::PixelViz *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  unsigned int result;
  
  if (!SWIG_check_num_args("PixelViz_height_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PixelViz, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PixelViz_height_get" "', argument " "1"" of type '" "iDynTree::PixelViz *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PixelViz * >(argp1);
  result = (unsigned int) ((arg1)->height);
  _out = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_PixelViz(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::PixelViz *result = 0 ;
  
  if (!SWIG_check_num_args("new_PixelViz",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::PixelViz *)new iDynTree::PixelViz();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__PixelViz, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_PixelViz(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::PixelViz *arg1 = (iDynTree::PixelViz *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_PixelViz",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__PixelViz, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PixelViz" "', argument " "1"" of type '" "iDynTree::PixelViz *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::PixelViz * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ILight(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ILight *arg1 = (iDynTree::ILight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ILight",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILight, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ILight" "', argument " "1"" of type '" "iDynTree::ILight *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ILight * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ILight_getName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ILight *arg1 = (iDynTree::ILight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string *result = 0 ;
  
  if (!SWIG_check_num_args("ILight_getName",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILight_getName" "', argument " "1"" of type '" "iDynTree::ILight const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ILight * >(argp1);
  result = (std::string *) &((iDynTree::ILight const *)arg1)->getName();
  _out = SWIG_From_std_string(static_cast< std::string >(*result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ILight_setType(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ILight *arg1 = (iDynTree::ILight *) 0 ;
  iDynTree::LightType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ILight_setType",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILight_setType" "', argument " "1"" of type '" "iDynTree::ILight *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ILight * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ILight_setType" "', argument " "2"" of type '" "iDynTree::LightType""'");
  } 
  arg2 = static_cast< iDynTree::LightType >(val2);
  (arg1)->setType(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ILight_getType(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ILight *arg1 = (iDynTree::ILight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::LightType result;
  
  if (!SWIG_check_num_args("ILight_getType",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILight_getType" "', argument " "1"" of type '" "iDynTree::ILight *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ILight * >(argp1);
  result = (iDynTree::LightType)(arg1)->getType();
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ILight_setPosition(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ILight *arg1 = (iDynTree::ILight *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ILight_setPosition",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILight_setPosition" "', argument " "1"" of type '" "iDynTree::ILight *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ILight * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ILight_setPosition" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ILight_setPosition" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  (arg1)->setPosition((iDynTree::Position const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ILight_getPosition(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ILight *arg1 = (iDynTree::ILight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position result;
  
  if (!SWIG_check_num_args("ILight_getPosition",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILight_getPosition" "', argument " "1"" of type '" "iDynTree::ILight *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ILight * >(argp1);
  result = (arg1)->getPosition();
  _out = SWIG_NewPointerObj((new iDynTree::Position(static_cast< const iDynTree::Position& >(result))), SWIGTYPE_p_iDynTree__Position, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ILight_setDirection(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ILight *arg1 = (iDynTree::ILight *) 0 ;
  iDynTree::Direction *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ILight_setDirection",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILight_setDirection" "', argument " "1"" of type '" "iDynTree::ILight *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ILight * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ILight_setDirection" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ILight_setDirection" "', argument " "2"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Direction * >(argp2);
  (arg1)->setDirection((iDynTree::Direction const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ILight_getDirection(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ILight *arg1 = (iDynTree::ILight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Direction result;
  
  if (!SWIG_check_num_args("ILight_getDirection",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILight_getDirection" "', argument " "1"" of type '" "iDynTree::ILight *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ILight * >(argp1);
  result = (arg1)->getDirection();
  _out = SWIG_NewPointerObj((new iDynTree::Direction(static_cast< const iDynTree::Direction& >(result))), SWIGTYPE_p_iDynTree__Direction, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ILight_setAmbientColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ILight *arg1 = (iDynTree::ILight *) 0 ;
  iDynTree::ColorViz *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ILight_setAmbientColor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILight_setAmbientColor" "', argument " "1"" of type '" "iDynTree::ILight *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ILight * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ColorViz,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ILight_setAmbientColor" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ILight_setAmbientColor" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ColorViz * >(argp2);
  (arg1)->setAmbientColor((iDynTree::ColorViz const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ILight_getAmbientColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ILight *arg1 = (iDynTree::ILight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ColorViz result;
  
  if (!SWIG_check_num_args("ILight_getAmbientColor",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILight_getAmbientColor" "', argument " "1"" of type '" "iDynTree::ILight *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ILight * >(argp1);
  result = (arg1)->getAmbientColor();
  _out = SWIG_NewPointerObj((new iDynTree::ColorViz(static_cast< const iDynTree::ColorViz& >(result))), SWIGTYPE_p_iDynTree__ColorViz, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ILight_setSpecularColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ILight *arg1 = (iDynTree::ILight *) 0 ;
  iDynTree::ColorViz *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ILight_setSpecularColor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILight_setSpecularColor" "', argument " "1"" of type '" "iDynTree::ILight *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ILight * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ColorViz,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ILight_setSpecularColor" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ILight_setSpecularColor" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ColorViz * >(argp2);
  (arg1)->setSpecularColor((iDynTree::ColorViz const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ILight_getSpecularColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ILight *arg1 = (iDynTree::ILight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ColorViz result;
  
  if (!SWIG_check_num_args("ILight_getSpecularColor",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILight_getSpecularColor" "', argument " "1"" of type '" "iDynTree::ILight *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ILight * >(argp1);
  result = (arg1)->getSpecularColor();
  _out = SWIG_NewPointerObj((new iDynTree::ColorViz(static_cast< const iDynTree::ColorViz& >(result))), SWIGTYPE_p_iDynTree__ColorViz, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ILight_setDiffuseColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ILight *arg1 = (iDynTree::ILight *) 0 ;
  iDynTree::ColorViz *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ILight_setDiffuseColor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILight_setDiffuseColor" "', argument " "1"" of type '" "iDynTree::ILight *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ILight * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ColorViz,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ILight_setDiffuseColor" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ILight_setDiffuseColor" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ColorViz * >(argp2);
  (arg1)->setDiffuseColor((iDynTree::ColorViz const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ILight_getDiffuseColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ILight *arg1 = (iDynTree::ILight *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ColorViz result;
  
  if (!SWIG_check_num_args("ILight_getDiffuseColor",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ILight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ILight_getDiffuseColor" "', argument " "1"" of type '" "iDynTree::ILight *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ILight * >(argp1);
  result = (arg1)->getDiffuseColor();
  _out = SWIG_NewPointerObj((new iDynTree::ColorViz(static_cast< const iDynTree::ColorViz& >(result))), SWIGTYPE_p_iDynTree__ColorViz, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_IEnvironment(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IEnvironment *arg1 = (iDynTree::IEnvironment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_IEnvironment",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IEnvironment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IEnvironment" "', argument " "1"" of type '" "iDynTree::IEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IEnvironment * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IEnvironment_getElements(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IEnvironment *arg1 = (iDynTree::IEnvironment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!SWIG_check_num_args("IEnvironment_getElements",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEnvironment_getElements" "', argument " "1"" of type '" "iDynTree::IEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IEnvironment * >(argp1);
  result = (arg1)->getElements();
  _out = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IEnvironment_setElementVisibility(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IEnvironment *arg1 = (iDynTree::IEnvironment *) 0 ;
  std::string arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IEnvironment_setElementVisibility",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEnvironment_setElementVisibility" "', argument " "1"" of type '" "iDynTree::IEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IEnvironment * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "IEnvironment_setElementVisibility" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IEnvironment_setElementVisibility" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->setElementVisibility(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IEnvironment_setBackgroundColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IEnvironment *arg1 = (iDynTree::IEnvironment *) 0 ;
  iDynTree::ColorViz *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IEnvironment_setBackgroundColor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEnvironment_setBackgroundColor" "', argument " "1"" of type '" "iDynTree::IEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ColorViz,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IEnvironment_setBackgroundColor" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IEnvironment_setBackgroundColor" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ColorViz * >(argp2);
  (arg1)->setBackgroundColor((iDynTree::ColorViz const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IEnvironment_setFloorGridColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IEnvironment *arg1 = (iDynTree::IEnvironment *) 0 ;
  iDynTree::ColorViz *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IEnvironment_setFloorGridColor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEnvironment_setFloorGridColor" "', argument " "1"" of type '" "iDynTree::IEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ColorViz,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IEnvironment_setFloorGridColor" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IEnvironment_setFloorGridColor" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ColorViz * >(argp2);
  (arg1)->setFloorGridColor((iDynTree::ColorViz const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IEnvironment_setAmbientLight(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IEnvironment *arg1 = (iDynTree::IEnvironment *) 0 ;
  iDynTree::ColorViz *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IEnvironment_setAmbientLight",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEnvironment_setAmbientLight" "', argument " "1"" of type '" "iDynTree::IEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IEnvironment * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ColorViz,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IEnvironment_setAmbientLight" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IEnvironment_setAmbientLight" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ColorViz * >(argp2);
  (arg1)->setAmbientLight((iDynTree::ColorViz const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IEnvironment_getLights(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IEnvironment *arg1 = (iDynTree::IEnvironment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!SWIG_check_num_args("IEnvironment_getLights",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEnvironment_getLights" "', argument " "1"" of type '" "iDynTree::IEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IEnvironment * >(argp1);
  result = (arg1)->getLights();
  _out = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IEnvironment_addLight(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IEnvironment *arg1 = (iDynTree::IEnvironment *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IEnvironment_addLight",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEnvironment_addLight" "', argument " "1"" of type '" "iDynTree::IEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IEnvironment * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IEnvironment_addLight" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IEnvironment_addLight" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->addLight((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_IEnvironment_lightViz(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IEnvironment *arg1 = (iDynTree::IEnvironment *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  iDynTree::ILight *result = 0 ;
  
  if (!SWIG_check_num_args("IEnvironment_lightViz",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEnvironment_lightViz" "', argument " "1"" of type '" "iDynTree::IEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IEnvironment * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IEnvironment_lightViz" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IEnvironment_lightViz" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (iDynTree::ILight *) &(arg1)->lightViz((std::string const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ILight, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_IEnvironment_removeLight(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IEnvironment *arg1 = (iDynTree::IEnvironment *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IEnvironment_removeLight",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IEnvironment, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IEnvironment_removeLight" "', argument " "1"" of type '" "iDynTree::IEnvironment *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IEnvironment * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IEnvironment_removeLight" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IEnvironment_removeLight" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->removeLight((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_delete_IJetsVisualization(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJetsVisualization *arg1 = (iDynTree::IJetsVisualization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_IJetsVisualization",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJetsVisualization, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IJetsVisualization" "', argument " "1"" of type '" "iDynTree::IJetsVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJetsVisualization * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJetsVisualization_setJetsFrames(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJetsVisualization *arg1 = (iDynTree::IJetsVisualization *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IJetsVisualization_setJetsFrames",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJetsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJetsVisualization_setJetsFrames" "', argument " "1"" of type '" "iDynTree::IJetsVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJetsVisualization * >(argp1);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IJetsVisualization_setJetsFrames" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJetsVisualization_setJetsFrames" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setJetsFrames((std::vector< std::string,std::allocator< std::string > > const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_IJetsVisualization_getNrOfJets(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJetsVisualization *arg1 = (iDynTree::IJetsVisualization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("IJetsVisualization_getNrOfJets",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJetsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJetsVisualization_getNrOfJets" "', argument " "1"" of type '" "iDynTree::IJetsVisualization const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJetsVisualization * >(argp1);
  result = ((iDynTree::IJetsVisualization const *)arg1)->getNrOfJets();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJetsVisualization_getJetDirection(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJetsVisualization *arg1 = (iDynTree::IJetsVisualization *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Direction result;
  
  if (!SWIG_check_num_args("IJetsVisualization_getJetDirection",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJetsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJetsVisualization_getJetDirection" "', argument " "1"" of type '" "iDynTree::IJetsVisualization const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJetsVisualization * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IJetsVisualization_getJetDirection" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  result = ((iDynTree::IJetsVisualization const *)arg1)->getJetDirection(arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Direction(static_cast< const iDynTree::Direction& >(result))), SWIGTYPE_p_iDynTree__Direction, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJetsVisualization_setJetDirection(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJetsVisualization *arg1 = (iDynTree::IJetsVisualization *) 0 ;
  int arg2 ;
  iDynTree::Direction *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IJetsVisualization_setJetDirection",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJetsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJetsVisualization_setJetDirection" "', argument " "1"" of type '" "iDynTree::IJetsVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJetsVisualization * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IJetsVisualization_setJetDirection" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IJetsVisualization_setJetDirection" "', argument " "3"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJetsVisualization_setJetDirection" "', argument " "3"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Direction * >(argp3);
  result = (bool)(arg1)->setJetDirection(arg2,(iDynTree::Direction const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJetsVisualization_setJetColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJetsVisualization *arg1 = (iDynTree::IJetsVisualization *) 0 ;
  int arg2 ;
  iDynTree::ColorViz *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IJetsVisualization_setJetColor",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJetsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJetsVisualization_setJetColor" "', argument " "1"" of type '" "iDynTree::IJetsVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJetsVisualization * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IJetsVisualization_setJetColor" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__ColorViz,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IJetsVisualization_setJetColor" "', argument " "3"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJetsVisualization_setJetColor" "', argument " "3"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::ColorViz * >(argp3);
  result = (bool)(arg1)->setJetColor(arg2,(iDynTree::ColorViz const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJetsVisualization_setJetsDimensions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJetsVisualization *arg1 = (iDynTree::IJetsVisualization *) 0 ;
  double *arg2 = 0 ;
  double *arg3 = 0 ;
  double *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  double temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  double temp4 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IJetsVisualization_setJetsDimensions",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJetsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJetsVisualization_setJetsDimensions" "', argument " "1"" of type '" "iDynTree::IJetsVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJetsVisualization * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IJetsVisualization_setJetsDimensions" "', argument " "2"" of type '" "double""'");
  } 
  temp2 = static_cast< double >(val2);
  arg2 = &temp2;
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IJetsVisualization_setJetsDimensions" "', argument " "3"" of type '" "double""'");
  } 
  temp3 = static_cast< double >(val3);
  arg3 = &temp3;
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IJetsVisualization_setJetsDimensions" "', argument " "4"" of type '" "double""'");
  } 
  temp4 = static_cast< double >(val4);
  arg4 = &temp4;
  result = (bool)(arg1)->setJetsDimensions((double const &)*arg2,(double const &)*arg3,(double const &)*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IJetsVisualization_setJetsIntensity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IJetsVisualization *arg1 = (iDynTree::IJetsVisualization *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IJetsVisualization_setJetsIntensity",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IJetsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IJetsVisualization_setJetsIntensity" "', argument " "1"" of type '" "iDynTree::IJetsVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IJetsVisualization * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IJetsVisualization_setJetsIntensity" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IJetsVisualization_setJetsIntensity" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  result = (bool)(arg1)->setJetsIntensity((iDynTree::VectorDynSize const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_IVectorsVisualization(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IVectorsVisualization *arg1 = (iDynTree::IVectorsVisualization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_IVectorsVisualization",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IVectorsVisualization, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IVectorsVisualization" "', argument " "1"" of type '" "iDynTree::IVectorsVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IVectorsVisualization * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IVectorsVisualization_addVector__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IVectorsVisualization *arg1 = (iDynTree::IVectorsVisualization *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  iDynTree::Direction *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("IVectorsVisualization_addVector",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IVectorsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IVectorsVisualization_addVector" "', argument " "1"" of type '" "iDynTree::IVectorsVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IVectorsVisualization * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IVectorsVisualization_addVector" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IVectorsVisualization_addVector" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IVectorsVisualization_addVector" "', argument " "3"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IVectorsVisualization_addVector" "', argument " "3"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Direction * >(argp3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IVectorsVisualization_addVector" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (arg1)->addVector((iDynTree::Position const &)*arg2,(iDynTree::Direction const &)*arg3,arg4);
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IVectorsVisualization_addVector__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IVectorsVisualization *arg1 = (iDynTree::IVectorsVisualization *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  iDynTree::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("IVectorsVisualization_addVector",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IVectorsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IVectorsVisualization_addVector" "', argument " "1"" of type '" "iDynTree::IVectorsVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IVectorsVisualization * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IVectorsVisualization_addVector" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IVectorsVisualization_addVector" "', argument " "2"" of type '" "iDynTree::Position const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IVectorsVisualization_addVector" "', argument " "3"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IVectorsVisualization_addVector" "', argument " "3"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Vector3 * >(argp3);
  result = (arg1)->addVector((iDynTree::Position const &)*arg2,(iDynTree::Vector3 const &)*arg3);
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IVectorsVisualization_addVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__IVectorsVisualization, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IVectorsVisualization_addVector__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__IVectorsVisualization, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_IVectorsVisualization_addVector__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'IVectorsVisualization_addVector'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::IVectorsVisualization::addVector(iDynTree::Position const &,iDynTree::Direction const &,double)\n"
    "    iDynTree::IVectorsVisualization::addVector(iDynTree::Position const &,iDynTree::Vector3 const &)\n");
  return 1;
}


int _wrap_IVectorsVisualization_getNrOfVectors(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IVectorsVisualization *arg1 = (iDynTree::IVectorsVisualization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("IVectorsVisualization_getNrOfVectors",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IVectorsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IVectorsVisualization_getNrOfVectors" "', argument " "1"" of type '" "iDynTree::IVectorsVisualization const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IVectorsVisualization * >(argp1);
  result = ((iDynTree::IVectorsVisualization const *)arg1)->getNrOfVectors();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IVectorsVisualization_getVector__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IVectorsVisualization *arg1 = (iDynTree::IVectorsVisualization *) 0 ;
  size_t arg2 ;
  iDynTree::Position *arg3 = 0 ;
  iDynTree::Direction *arg4 = 0 ;
  double *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IVectorsVisualization_getVector",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IVectorsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IVectorsVisualization_getVector" "', argument " "1"" of type '" "iDynTree::IVectorsVisualization const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IVectorsVisualization * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IVectorsVisualization_getVector" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IVectorsVisualization_getVector" "', argument " "3"" of type '" "iDynTree::Position &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IVectorsVisualization_getVector" "', argument " "3"" of type '" "iDynTree::Position &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Position * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IVectorsVisualization_getVector" "', argument " "4"" of type '" "iDynTree::Direction &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IVectorsVisualization_getVector" "', argument " "4"" of type '" "iDynTree::Direction &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Direction * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_double,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IVectorsVisualization_getVector" "', argument " "5"" of type '" "double &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IVectorsVisualization_getVector" "', argument " "5"" of type '" "double &""'"); 
  }
  arg5 = reinterpret_cast< double * >(argp5);
  result = (bool)((iDynTree::IVectorsVisualization const *)arg1)->getVector(arg2,*arg3,*arg4,*arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IVectorsVisualization_getVector__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IVectorsVisualization *arg1 = (iDynTree::IVectorsVisualization *) 0 ;
  size_t arg2 ;
  iDynTree::Position *arg3 = 0 ;
  iDynTree::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IVectorsVisualization_getVector",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IVectorsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IVectorsVisualization_getVector" "', argument " "1"" of type '" "iDynTree::IVectorsVisualization const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IVectorsVisualization * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IVectorsVisualization_getVector" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IVectorsVisualization_getVector" "', argument " "3"" of type '" "iDynTree::Position &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IVectorsVisualization_getVector" "', argument " "3"" of type '" "iDynTree::Position &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Position * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IVectorsVisualization_getVector" "', argument " "4"" of type '" "iDynTree::Vector3 &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IVectorsVisualization_getVector" "', argument " "4"" of type '" "iDynTree::Vector3 &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Vector3 * >(argp4);
  result = (bool)((iDynTree::IVectorsVisualization const *)arg1)->getVector(arg2,*arg3,*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IVectorsVisualization_getVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__IVectorsVisualization, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_IVectorsVisualization_getVector__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__IVectorsVisualization, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_IVectorsVisualization_getVector__SWIG_0(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'IVectorsVisualization_getVector'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::IVectorsVisualization::getVector(size_t,iDynTree::Position &,iDynTree::Direction &,double &) const\n"
    "    iDynTree::IVectorsVisualization::getVector(size_t,iDynTree::Position &,iDynTree::Vector3 &) const\n");
  return 1;
}


int _wrap_IVectorsVisualization_updateVector__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IVectorsVisualization *arg1 = (iDynTree::IVectorsVisualization *) 0 ;
  size_t arg2 ;
  iDynTree::Position *arg3 = 0 ;
  iDynTree::Direction *arg4 = 0 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IVectorsVisualization_updateVector",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IVectorsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IVectorsVisualization_updateVector" "', argument " "1"" of type '" "iDynTree::IVectorsVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IVectorsVisualization * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IVectorsVisualization_updateVector" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IVectorsVisualization_updateVector" "', argument " "3"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IVectorsVisualization_updateVector" "', argument " "3"" of type '" "iDynTree::Position const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Position * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Direction,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IVectorsVisualization_updateVector" "', argument " "4"" of type '" "iDynTree::Direction const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IVectorsVisualization_updateVector" "', argument " "4"" of type '" "iDynTree::Direction const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Direction * >(argp4);
  ecode5 = SWIG_AsVal_double(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IVectorsVisualization_updateVector" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (bool)(arg1)->updateVector(arg2,(iDynTree::Position const &)*arg3,(iDynTree::Direction const &)*arg4,arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IVectorsVisualization_updateVector__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IVectorsVisualization *arg1 = (iDynTree::IVectorsVisualization *) 0 ;
  size_t arg2 ;
  iDynTree::Position *arg3 = 0 ;
  iDynTree::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IVectorsVisualization_updateVector",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IVectorsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IVectorsVisualization_updateVector" "', argument " "1"" of type '" "iDynTree::IVectorsVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IVectorsVisualization * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IVectorsVisualization_updateVector" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IVectorsVisualization_updateVector" "', argument " "3"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IVectorsVisualization_updateVector" "', argument " "3"" of type '" "iDynTree::Position const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Position * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IVectorsVisualization_updateVector" "', argument " "4"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IVectorsVisualization_updateVector" "', argument " "4"" of type '" "iDynTree::Vector3 const &""'"); 
  }
  arg4 = reinterpret_cast< iDynTree::Vector3 * >(argp4);
  result = (bool)(arg1)->updateVector(arg2,(iDynTree::Position const &)*arg3,(iDynTree::Vector3 const &)*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IVectorsVisualization_updateVector(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__IVectorsVisualization, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_IVectorsVisualization_updateVector__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__IVectorsVisualization, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_IVectorsVisualization_updateVector__SWIG_0(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'IVectorsVisualization_updateVector'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::IVectorsVisualization::updateVector(size_t,iDynTree::Position const &,iDynTree::Direction const &,double)\n"
    "    iDynTree::IVectorsVisualization::updateVector(size_t,iDynTree::Position const &,iDynTree::Vector3 const &)\n");
  return 1;
}


int _wrap_IVectorsVisualization_setVectorColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IVectorsVisualization *arg1 = (iDynTree::IVectorsVisualization *) 0 ;
  size_t arg2 ;
  iDynTree::ColorViz *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IVectorsVisualization_setVectorColor",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IVectorsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IVectorsVisualization_setVectorColor" "', argument " "1"" of type '" "iDynTree::IVectorsVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IVectorsVisualization * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IVectorsVisualization_setVectorColor" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__ColorViz,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IVectorsVisualization_setVectorColor" "', argument " "3"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IVectorsVisualization_setVectorColor" "', argument " "3"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::ColorViz * >(argp3);
  result = (bool)(arg1)->setVectorColor(arg2,(iDynTree::ColorViz const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IVectorsVisualization_setVectorsAspect(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IVectorsVisualization *arg1 = (iDynTree::IVectorsVisualization *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IVectorsVisualization_setVectorsAspect",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IVectorsVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IVectorsVisualization_setVectorsAspect" "', argument " "1"" of type '" "iDynTree::IVectorsVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IVectorsVisualization * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IVectorsVisualization_setVectorsAspect" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IVectorsVisualization_setVectorsAspect" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IVectorsVisualization_setVectorsAspect" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->setVectorsAspect(arg2,arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_IFrameVisualization(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IFrameVisualization *arg1 = (iDynTree::IFrameVisualization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_IFrameVisualization",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IFrameVisualization, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IFrameVisualization" "', argument " "1"" of type '" "iDynTree::IFrameVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IFrameVisualization * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IFrameVisualization_addFrame__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IFrameVisualization *arg1 = (iDynTree::IFrameVisualization *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("IFrameVisualization_addFrame",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IFrameVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFrameVisualization_addFrame" "', argument " "1"" of type '" "iDynTree::IFrameVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IFrameVisualization * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IFrameVisualization_addFrame" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFrameVisualization_addFrame" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IFrameVisualization_addFrame" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (arg1)->addFrame((iDynTree::Transform const &)*arg2,arg3);
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IFrameVisualization_addFrame__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IFrameVisualization *arg1 = (iDynTree::IFrameVisualization *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("IFrameVisualization_addFrame",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IFrameVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFrameVisualization_addFrame" "', argument " "1"" of type '" "iDynTree::IFrameVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IFrameVisualization * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IFrameVisualization_addFrame" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFrameVisualization_addFrame" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  result = (arg1)->addFrame((iDynTree::Transform const &)*arg2);
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IFrameVisualization_addFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__IFrameVisualization, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_IFrameVisualization_addFrame__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__IFrameVisualization, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_IFrameVisualization_addFrame__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'IFrameVisualization_addFrame'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::IFrameVisualization::addFrame(iDynTree::Transform const &,double)\n"
    "    iDynTree::IFrameVisualization::addFrame(iDynTree::Transform const &)\n");
  return 1;
}


int _wrap_IFrameVisualization_setVisible(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IFrameVisualization *arg1 = (iDynTree::IFrameVisualization *) 0 ;
  size_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IFrameVisualization_setVisible",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IFrameVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFrameVisualization_setVisible" "', argument " "1"" of type '" "iDynTree::IFrameVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IFrameVisualization * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IFrameVisualization_setVisible" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IFrameVisualization_setVisible" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->setVisible(arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IFrameVisualization_getNrOfFrames(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IFrameVisualization *arg1 = (iDynTree::IFrameVisualization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("IFrameVisualization_getNrOfFrames",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IFrameVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFrameVisualization_getNrOfFrames" "', argument " "1"" of type '" "iDynTree::IFrameVisualization const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IFrameVisualization * >(argp1);
  result = ((iDynTree::IFrameVisualization const *)arg1)->getNrOfFrames();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IFrameVisualization_getFrameTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IFrameVisualization *arg1 = (iDynTree::IFrameVisualization *) 0 ;
  size_t arg2 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IFrameVisualization_getFrameTransform",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IFrameVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFrameVisualization_getFrameTransform" "', argument " "1"" of type '" "iDynTree::IFrameVisualization const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IFrameVisualization * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IFrameVisualization_getFrameTransform" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IFrameVisualization_getFrameTransform" "', argument " "3"" of type '" "iDynTree::Transform &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFrameVisualization_getFrameTransform" "', argument " "3"" of type '" "iDynTree::Transform &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)((iDynTree::IFrameVisualization const *)arg1)->getFrameTransform(arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IFrameVisualization_updateFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IFrameVisualization *arg1 = (iDynTree::IFrameVisualization *) 0 ;
  size_t arg2 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IFrameVisualization_updateFrame",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IFrameVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFrameVisualization_updateFrame" "', argument " "1"" of type '" "iDynTree::IFrameVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IFrameVisualization * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IFrameVisualization_updateFrame" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IFrameVisualization_updateFrame" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IFrameVisualization_updateFrame" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)(arg1)->updateFrame(arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_IModelVisualization(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_IModelVisualization",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IModelVisualization" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IModelVisualization_setPositions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IModelVisualization_setPositions",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_setPositions" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IModelVisualization_setPositions" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IModelVisualization_setPositions" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IModelVisualization_setPositions" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IModelVisualization_setPositions" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  result = (bool)(arg1)->setPositions((iDynTree::Transform const &)*arg2,(iDynTree::VectorDynSize const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IModelVisualization_setLinkPositions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  iDynTree::LinkPositions *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IModelVisualization_setLinkPositions",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_setLinkPositions" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__LinkPositions,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IModelVisualization_setLinkPositions" "', argument " "2"" of type '" "iDynTree::LinkPositions const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IModelVisualization_setLinkPositions" "', argument " "2"" of type '" "iDynTree::LinkPositions const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::LinkPositions * >(argp2);
  result = (bool)(arg1)->setLinkPositions((iDynTree::LinkPositions const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IModelVisualization_model(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Model *result = 0 ;
  
  if (!SWIG_check_num_args("IModelVisualization_model",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_model" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  result = (iDynTree::Model *) &(arg1)->model();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IModelVisualization_getInstanceName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("IModelVisualization_getInstanceName",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_getInstanceName" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  result = (arg1)->getInstanceName();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IModelVisualization_setModelVisibility(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IModelVisualization_setModelVisibility",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_setModelVisibility" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IModelVisualization_setModelVisibility" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setModelVisibility(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IModelVisualization_setModelColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  iDynTree::ColorViz *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IModelVisualization_setModelColor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_setModelColor" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__ColorViz,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IModelVisualization_setModelColor" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IModelVisualization_setModelColor" "', argument " "2"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::ColorViz * >(argp2);
  (arg1)->setModelColor((iDynTree::ColorViz const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IModelVisualization_resetModelColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("IModelVisualization_resetModelColor",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_resetModelColor" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  (arg1)->resetModelColor();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IModelVisualization_setLinkColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  iDynTree::LinkIndex *arg2 = 0 ;
  iDynTree::ColorViz *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  iDynTree::LinkIndex temp2 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IModelVisualization_setLinkColor",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_setLinkColor" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IModelVisualization_setLinkColor" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  temp2 = static_cast< iDynTree::LinkIndex >(val2);
  arg2 = &temp2;
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__ColorViz,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IModelVisualization_setLinkColor" "', argument " "3"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IModelVisualization_setLinkColor" "', argument " "3"" of type '" "iDynTree::ColorViz const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::ColorViz * >(argp3);
  result = (bool)(arg1)->setLinkColor((iDynTree::LinkIndex const &)*arg2,(iDynTree::ColorViz const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IModelVisualization_resetLinkColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  iDynTree::LinkIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  iDynTree::LinkIndex temp2 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IModelVisualization_resetLinkColor",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_resetLinkColor" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IModelVisualization_resetLinkColor" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  temp2 = static_cast< iDynTree::LinkIndex >(val2);
  arg2 = &temp2;
  result = (bool)(arg1)->resetLinkColor((iDynTree::LinkIndex const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IModelVisualization_getLinkNames(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!SWIG_check_num_args("IModelVisualization_getLinkNames",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_getLinkNames" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  result = (arg1)->getLinkNames();
  _out = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IModelVisualization_setLinkVisibility(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IModelVisualization_setLinkVisibility",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_setLinkVisibility" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IModelVisualization_setLinkVisibility" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IModelVisualization_setLinkVisibility" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IModelVisualization_setLinkVisibility" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->setLinkVisibility((std::string const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_IModelVisualization_getFeatures(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< std::string,std::allocator< std::string > > result;
  
  if (!SWIG_check_num_args("IModelVisualization_getFeatures",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_getFeatures" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  result = (arg1)->getFeatures();
  _out = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IModelVisualization_setFeatureVisibility(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  std::string *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("IModelVisualization_setFeatureVisibility",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_setFeatureVisibility" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IModelVisualization_setFeatureVisibility" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IModelVisualization_setFeatureVisibility" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IModelVisualization_setFeatureVisibility" "', argument " "3"" of type '" "bool""'");
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->setFeatureVisibility((std::string const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_IModelVisualization_jets(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::IJetsVisualization *result = 0 ;
  
  if (!SWIG_check_num_args("IModelVisualization_jets",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_jets" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  result = (iDynTree::IJetsVisualization *) &(arg1)->jets();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IJetsVisualization, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IModelVisualization_getWorldModelTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("IModelVisualization_getWorldModelTransform",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_getWorldModelTransform" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  result = (arg1)->getWorldModelTransform();
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_IModelVisualization_getWorldLinkTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::IModelVisualization *arg1 = (iDynTree::IModelVisualization *) 0 ;
  iDynTree::LinkIndex *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  iDynTree::LinkIndex temp2 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Transform result;
  
  if (!SWIG_check_num_args("IModelVisualization_getWorldLinkTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IModelVisualization_getWorldLinkTransform" "', argument " "1"" of type '" "iDynTree::IModelVisualization *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::IModelVisualization * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IModelVisualization_getWorldLinkTransform" "', argument " "2"" of type '" "iDynTree::LinkIndex""'");
  } 
  temp2 = static_cast< iDynTree::LinkIndex >(val2);
  arg2 = &temp2;
  result = (arg1)->getWorldLinkTransform((iDynTree::LinkIndex const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Transform(static_cast< const iDynTree::Transform& >(result))), SWIGTYPE_p_iDynTree__Transform, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ITexture(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ITexture *arg1 = (iDynTree::ITexture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ITexture",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ITexture, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ITexture" "', argument " "1"" of type '" "iDynTree::ITexture *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ITexture * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ITexture_environment(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ITexture *arg1 = (iDynTree::ITexture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::IEnvironment *result = 0 ;
  
  if (!SWIG_check_num_args("ITexture_environment",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ITexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ITexture_environment" "', argument " "1"" of type '" "iDynTree::ITexture *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ITexture * >(argp1);
  result = (iDynTree::IEnvironment *) &(arg1)->environment();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IEnvironment, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ITexture_getPixelColor(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ITexture *arg1 = (iDynTree::ITexture *) 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  iDynTree::ColorViz result;
  
  if (!SWIG_check_num_args("ITexture_getPixelColor",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ITexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ITexture_getPixelColor" "', argument " "1"" of type '" "iDynTree::ITexture const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ITexture * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ITexture_getPixelColor" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ITexture_getPixelColor" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = ((iDynTree::ITexture const *)arg1)->getPixelColor(arg2,arg3);
  _out = SWIG_NewPointerObj((new iDynTree::ColorViz(static_cast< const iDynTree::ColorViz& >(result))), SWIGTYPE_p_iDynTree__ColorViz, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ITexture_getPixels(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ITexture *arg1 = (iDynTree::ITexture *) 0 ;
  std::vector< iDynTree::PixelViz,std::allocator< iDynTree::PixelViz > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ITexture_getPixels",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ITexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ITexture_getPixels" "', argument " "1"" of type '" "iDynTree::ITexture const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ITexture * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__vectorT_iDynTree__PixelViz_std__allocatorT_iDynTree__PixelViz_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ITexture_getPixels" "', argument " "2"" of type '" "std::vector< iDynTree::PixelViz,std::allocator< iDynTree::PixelViz > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ITexture_getPixels" "', argument " "2"" of type '" "std::vector< iDynTree::PixelViz,std::allocator< iDynTree::PixelViz > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::PixelViz,std::allocator< iDynTree::PixelViz > > * >(argp2);
  result = (bool)((iDynTree::ITexture const *)arg1)->getPixels(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VisualizerOptions_verbose_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VisualizerOptions *arg1 = (iDynTree::VisualizerOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("VisualizerOptions_verbose_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VisualizerOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualizerOptions_verbose_set" "', argument " "1"" of type '" "iDynTree::VisualizerOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VisualizerOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VisualizerOptions_verbose_set" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->verbose = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VisualizerOptions_verbose_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VisualizerOptions *arg1 = (iDynTree::VisualizerOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("VisualizerOptions_verbose_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VisualizerOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualizerOptions_verbose_get" "', argument " "1"" of type '" "iDynTree::VisualizerOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VisualizerOptions * >(argp1);
  result = (bool) ((arg1)->verbose);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VisualizerOptions_winWidth_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VisualizerOptions *arg1 = (iDynTree::VisualizerOptions *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("VisualizerOptions_winWidth_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VisualizerOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualizerOptions_winWidth_set" "', argument " "1"" of type '" "iDynTree::VisualizerOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VisualizerOptions * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VisualizerOptions_winWidth_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->winWidth = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VisualizerOptions_winWidth_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VisualizerOptions *arg1 = (iDynTree::VisualizerOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  int result;
  
  if (!SWIG_check_num_args("VisualizerOptions_winWidth_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VisualizerOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualizerOptions_winWidth_get" "', argument " "1"" of type '" "iDynTree::VisualizerOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VisualizerOptions * >(argp1);
  result = (int) ((arg1)->winWidth);
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VisualizerOptions_winHeight_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VisualizerOptions *arg1 = (iDynTree::VisualizerOptions *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("VisualizerOptions_winHeight_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VisualizerOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualizerOptions_winHeight_set" "', argument " "1"" of type '" "iDynTree::VisualizerOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VisualizerOptions * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VisualizerOptions_winHeight_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->winHeight = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VisualizerOptions_winHeight_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VisualizerOptions *arg1 = (iDynTree::VisualizerOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  int result;
  
  if (!SWIG_check_num_args("VisualizerOptions_winHeight_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VisualizerOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualizerOptions_winHeight_get" "', argument " "1"" of type '" "iDynTree::VisualizerOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VisualizerOptions * >(argp1);
  result = (int) ((arg1)->winHeight);
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VisualizerOptions_rootFrameArrowsDimension_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VisualizerOptions *arg1 = (iDynTree::VisualizerOptions *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("VisualizerOptions_rootFrameArrowsDimension_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VisualizerOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualizerOptions_rootFrameArrowsDimension_set" "', argument " "1"" of type '" "iDynTree::VisualizerOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VisualizerOptions * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VisualizerOptions_rootFrameArrowsDimension_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->rootFrameArrowsDimension = arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_VisualizerOptions_rootFrameArrowsDimension_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VisualizerOptions *arg1 = (iDynTree::VisualizerOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("VisualizerOptions_rootFrameArrowsDimension_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VisualizerOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualizerOptions_rootFrameArrowsDimension_get" "', argument " "1"" of type '" "iDynTree::VisualizerOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VisualizerOptions * >(argp1);
  result = (double) ((arg1)->rootFrameArrowsDimension);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_VisualizerOptions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::VisualizerOptions *result = 0 ;
  
  if (!SWIG_check_num_args("new_VisualizerOptions",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::VisualizerOptions *)new iDynTree::VisualizerOptions();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VisualizerOptions, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_VisualizerOptions(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::VisualizerOptions *arg1 = (iDynTree::VisualizerOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_VisualizerOptions",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__VisualizerOptions, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualizerOptions" "', argument " "1"" of type '" "iDynTree::VisualizerOptions *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::VisualizerOptions * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ITexturesHandler(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ITexturesHandler *arg1 = (iDynTree::ITexturesHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ITexturesHandler",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ITexturesHandler, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ITexturesHandler" "', argument " "1"" of type '" "iDynTree::ITexturesHandler *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ITexturesHandler * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ITexturesHandler_add__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ITexturesHandler *arg1 = (iDynTree::ITexturesHandler *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::VisualizerOptions *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  iDynTree::ITexture *result = 0 ;
  
  if (!SWIG_check_num_args("ITexturesHandler_add",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ITexturesHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ITexturesHandler_add" "', argument " "1"" of type '" "iDynTree::ITexturesHandler *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ITexturesHandler * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ITexturesHandler_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ITexturesHandler_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VisualizerOptions,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ITexturesHandler_add" "', argument " "3"" of type '" "iDynTree::VisualizerOptions const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ITexturesHandler_add" "', argument " "3"" of type '" "iDynTree::VisualizerOptions const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VisualizerOptions * >(argp3);
  result = (iDynTree::ITexture *)(arg1)->add((std::string const &)*arg2,(iDynTree::VisualizerOptions const &)*arg3);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ITexture, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ITexturesHandler_add__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ITexturesHandler *arg1 = (iDynTree::ITexturesHandler *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  iDynTree::ITexture *result = 0 ;
  
  if (!SWIG_check_num_args("ITexturesHandler_add",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ITexturesHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ITexturesHandler_add" "', argument " "1"" of type '" "iDynTree::ITexturesHandler *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ITexturesHandler * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ITexturesHandler_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ITexturesHandler_add" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (iDynTree::ITexture *)(arg1)->add((std::string const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ITexture, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_ITexturesHandler_add(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ITexturesHandler, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ITexturesHandler_add__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__ITexturesHandler, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VisualizerOptions, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ITexturesHandler_add__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'ITexturesHandler_add'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::ITexturesHandler::add(std::string const &,iDynTree::VisualizerOptions const &)\n"
    "    iDynTree::ITexturesHandler::add(std::string const &)\n");
  return 1;
}


int _wrap_ITexturesHandler_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ITexturesHandler *arg1 = (iDynTree::ITexturesHandler *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  iDynTree::ITexture *result = 0 ;
  
  if (!SWIG_check_num_args("ITexturesHandler_get",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ITexturesHandler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ITexturesHandler_get" "', argument " "1"" of type '" "iDynTree::ITexturesHandler *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ITexturesHandler * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ITexturesHandler_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ITexturesHandler_get" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (iDynTree::ITexture *)(arg1)->get((std::string const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ITexture, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_new_Visualizer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Visualizer *result = 0 ;
  
  if (!SWIG_check_num_args("new_Visualizer",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Visualizer *)new iDynTree::Visualizer();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Visualizer, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Visualizer(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Visualizer",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Visualizer" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_init__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  iDynTree::VisualizerOptions *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Visualizer_init",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_init" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VisualizerOptions,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Visualizer_init" "', argument " "2"" of type '" "iDynTree::VisualizerOptions const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Visualizer_init" "', argument " "2"" of type '" "iDynTree::VisualizerOptions const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VisualizerOptions * >(argp2);
  result = (bool)(arg1)->init((iDynTree::VisualizerOptions const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_init__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Visualizer_init",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_init" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  result = (bool)(arg1)->init();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_init(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Visualizer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Visualizer_init__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Visualizer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VisualizerOptions, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Visualizer_init__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Visualizer_init'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Visualizer::init(iDynTree::VisualizerOptions const &)\n"
    "    iDynTree::Visualizer::init()\n");
  return 1;
}


int _wrap_Visualizer_getNrOfVisualizedModels(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("Visualizer_getNrOfVisualizedModels",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_getNrOfVisualizedModels" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  result = (arg1)->getNrOfVisualizedModels();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_getModelInstanceName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("Visualizer_getModelInstanceName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_getModelInstanceName" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Visualizer_getModelInstanceName" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (arg1)->getModelInstanceName(arg2);
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_getModelInstanceIndex(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  int result;
  
  if (!SWIG_check_num_args("Visualizer_getModelInstanceIndex",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_getModelInstanceIndex" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Visualizer_getModelInstanceIndex" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (int)(arg1)->getModelInstanceIndex(arg2);
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_addModel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  std::string *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Visualizer_addModel",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_addModel" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Visualizer_addModel" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Visualizer_addModel" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Visualizer_addModel" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Visualizer_addModel" "', argument " "3"" of type '" "std::string const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->addModel((iDynTree::Model const &)*arg2,(std::string const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_Visualizer_modelViz__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::IModelVisualization *result = 0 ;
  
  if (!SWIG_check_num_args("Visualizer_modelViz",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_modelViz" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Visualizer_modelViz" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (iDynTree::IModelVisualization *) &(arg1)->modelViz(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_modelViz__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  iDynTree::IModelVisualization *result = 0 ;
  
  if (!SWIG_check_num_args("Visualizer_modelViz",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_modelViz" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Visualizer_modelViz" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Visualizer_modelViz" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (iDynTree::IModelVisualization *) &(arg1)->modelViz((std::string const &)*arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IModelVisualization, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_Visualizer_modelViz(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Visualizer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Visualizer_modelViz__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Visualizer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Visualizer_modelViz__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Visualizer_modelViz'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Visualizer::modelViz(size_t)\n"
    "    iDynTree::Visualizer::modelViz(std::string const &)\n");
  return 1;
}


int _wrap_Visualizer_camera(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ICamera *result = 0 ;
  
  if (!SWIG_check_num_args("Visualizer_camera",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_camera" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  result = (iDynTree::ICamera *) &(arg1)->camera();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ICamera, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_enviroment(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::IEnvironment *result = 0 ;
  
  if (!SWIG_check_num_args("Visualizer_enviroment",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_enviroment" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  result = (iDynTree::IEnvironment *) &(arg1)->enviroment();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IEnvironment, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_vectors(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::IVectorsVisualization *result = 0 ;
  
  if (!SWIG_check_num_args("Visualizer_vectors",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_vectors" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  result = (iDynTree::IVectorsVisualization *) &(arg1)->vectors();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IVectorsVisualization, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_frames(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::IFrameVisualization *result = 0 ;
  
  if (!SWIG_check_num_args("Visualizer_frames",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_frames" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  result = (iDynTree::IFrameVisualization *) &(arg1)->frames();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__IFrameVisualization, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_textures(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::ITexturesHandler *result = 0 ;
  
  if (!SWIG_check_num_args("Visualizer_textures",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_textures" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  result = (iDynTree::ITexturesHandler *) &(arg1)->textures();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ITexturesHandler, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_run(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Visualizer_run",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_run" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  result = (bool)(arg1)->run();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_draw(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Visualizer_draw",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_draw" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  (arg1)->draw();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_drawToFile__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Visualizer_drawToFile",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_drawToFile" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Visualizer_drawToFile" "', argument " "2"" of type '" "std::string const""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)(arg1)->drawToFile(arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_drawToFile__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Visualizer_drawToFile",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_drawToFile" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  result = (bool)(arg1)->drawToFile();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_drawToFile(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Visualizer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Visualizer_drawToFile__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Visualizer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Visualizer_drawToFile__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Visualizer_drawToFile'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Visualizer::drawToFile(std::string const)\n"
    "    iDynTree::Visualizer::drawToFile()\n");
  return 1;
}


int _wrap_Visualizer_close(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Visualizer_close",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_close" "', argument " "1"" of type '" "iDynTree::Visualizer *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  (arg1)->close();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Visualizer_isWindowActive(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Visualizer *arg1 = (iDynTree::Visualizer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Visualizer_isWindowActive",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Visualizer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Visualizer_isWindowActive" "', argument " "1"" of type '" "iDynTree::Visualizer const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Visualizer * >(argp1);
  result = (bool)((iDynTree::Visualizer const *)arg1)->isWindowActive();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon_m_vertices_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon *arg1 = (iDynTree::Polygon *) 0 ;
  std::vector< iDynTree::Position,std::allocator< iDynTree::Position > > *arg2 = (std::vector< iDynTree::Position,std::allocator< iDynTree::Position > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Polygon_m_vertices_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon_m_vertices_set" "', argument " "1"" of type '" "iDynTree::Polygon *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__vectorT_iDynTree__Position_std__allocatorT_iDynTree__Position_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Polygon_m_vertices_set" "', argument " "2"" of type '" "std::vector< iDynTree::Position,std::allocator< iDynTree::Position > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::Position,std::allocator< iDynTree::Position > > * >(argp2);
  if (arg1) (arg1)->m_vertices = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon_m_vertices_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon *arg1 = (iDynTree::Polygon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::Position,std::allocator< iDynTree::Position > > *result = 0 ;
  
  if (!SWIG_check_num_args("Polygon_m_vertices_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon_m_vertices_get" "', argument " "1"" of type '" "iDynTree::Polygon *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon * >(argp1);
  result = (std::vector< iDynTree::Position,std::allocator< iDynTree::Position > > *)& ((arg1)->m_vertices);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__Position_std__allocatorT_iDynTree__Position_t_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Polygon(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Polygon *result = 0 ;
  
  if (!SWIG_check_num_args("new_Polygon",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Polygon *)new iDynTree::Polygon();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Polygon, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon_setNrOfVertices(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon *arg1 = (iDynTree::Polygon *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Polygon_setNrOfVertices",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon_setNrOfVertices" "', argument " "1"" of type '" "iDynTree::Polygon *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Polygon_setNrOfVertices" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setNrOfVertices(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon_getNrOfVertices(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon *arg1 = (iDynTree::Polygon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("Polygon_getNrOfVertices",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon_getNrOfVertices" "', argument " "1"" of type '" "iDynTree::Polygon const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon * >(argp1);
  result = ((iDynTree::Polygon const *)arg1)->getNrOfVertices();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon *arg1 = (iDynTree::Polygon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Polygon_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon_isValid" "', argument " "1"" of type '" "iDynTree::Polygon const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon * >(argp1);
  result = (bool)((iDynTree::Polygon const *)arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon_applyTransform(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon *arg1 = (iDynTree::Polygon *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  iDynTree::Polygon result;
  
  if (!SWIG_check_num_args("Polygon_applyTransform",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon_applyTransform" "', argument " "1"" of type '" "iDynTree::Polygon const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Polygon_applyTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Polygon_applyTransform" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  result = ((iDynTree::Polygon const *)arg1)->applyTransform((iDynTree::Transform const &)*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Polygon(static_cast< const iDynTree::Polygon& >(result))), SWIGTYPE_p_iDynTree__Polygon, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon *arg1 = (iDynTree::Polygon *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("Polygon_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon_paren" "', argument " "1"" of type '" "iDynTree::Polygon *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Polygon_paren" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (iDynTree::Position *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon *arg1 = (iDynTree::Polygon *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("Polygon_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon_paren" "', argument " "1"" of type '" "iDynTree::Polygon const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Polygon_paren" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (iDynTree::Position *) &((iDynTree::Polygon const *)arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Polygon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Polygon_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Polygon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Polygon_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Polygon_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Polygon::operator ()(size_t const)\n"
    "    iDynTree::Polygon::operator ()(size_t const) const\n");
  return 1;
}


int _wrap_Polygon_XYRectangleFromOffsets(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  iDynTree::Polygon result;
  
  if (!SWIG_check_num_args("Polygon_XYRectangleFromOffsets",argc,4,4,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_double(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Polygon_XYRectangleFromOffsets" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Polygon_XYRectangleFromOffsets" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Polygon_XYRectangleFromOffsets" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Polygon_XYRectangleFromOffsets" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = iDynTree::Polygon::XYRectangleFromOffsets(arg1,arg2,arg3,arg4);
  _out = SWIG_NewPointerObj((new iDynTree::Polygon(static_cast< const iDynTree::Polygon& >(result))), SWIGTYPE_p_iDynTree__Polygon, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_Polygon(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon *arg1 = (iDynTree::Polygon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Polygon",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Polygon" "', argument " "1"" of type '" "iDynTree::Polygon *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon2D_m_vertices_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon2D *arg1 = (iDynTree::Polygon2D *) 0 ;
  std::vector< iDynTree::Vector2,std::allocator< iDynTree::Vector2 > > *arg2 = (std::vector< iDynTree::Vector2,std::allocator< iDynTree::Vector2 > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Polygon2D_m_vertices_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon2D_m_vertices_set" "', argument " "1"" of type '" "iDynTree::Polygon2D *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon2D * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__vectorT_iDynTree__VectorFixSizeT_2_t_std__allocatorT_iDynTree__VectorFixSizeT_2_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Polygon2D_m_vertices_set" "', argument " "2"" of type '" "std::vector< iDynTree::Vector2,std::allocator< iDynTree::Vector2 > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::Vector2,std::allocator< iDynTree::Vector2 > > * >(argp2);
  if (arg1) (arg1)->m_vertices = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon2D_m_vertices_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon2D *arg1 = (iDynTree::Polygon2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::Vector2,std::allocator< iDynTree::Vector2 > > *result = 0 ;
  
  if (!SWIG_check_num_args("Polygon2D_m_vertices_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon2D_m_vertices_get" "', argument " "1"" of type '" "iDynTree::Polygon2D *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon2D * >(argp1);
  result = (std::vector< iDynTree::Vector2,std::allocator< iDynTree::Vector2 > > *)& ((arg1)->m_vertices);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__VectorFixSizeT_2_t_std__allocatorT_iDynTree__VectorFixSizeT_2_t_t_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_Polygon2D(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::Polygon2D *result = 0 ;
  
  if (!SWIG_check_num_args("new_Polygon2D",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::Polygon2D *)new iDynTree::Polygon2D();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Polygon2D, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon2D_setNrOfVertices(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon2D *arg1 = (iDynTree::Polygon2D *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("Polygon2D_setNrOfVertices",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon2D_setNrOfVertices" "', argument " "1"" of type '" "iDynTree::Polygon2D *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon2D * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Polygon2D_setNrOfVertices" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setNrOfVertices(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon2D_getNrOfVertices(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon2D *arg1 = (iDynTree::Polygon2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("Polygon2D_getNrOfVertices",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon2D_getNrOfVertices" "', argument " "1"" of type '" "iDynTree::Polygon2D const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon2D * >(argp1);
  result = ((iDynTree::Polygon2D const *)arg1)->getNrOfVertices();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon2D_isValid(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon2D *arg1 = (iDynTree::Polygon2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("Polygon2D_isValid",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon2D_isValid" "', argument " "1"" of type '" "iDynTree::Polygon2D const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon2D * >(argp1);
  result = (bool)((iDynTree::Polygon2D const *)arg1)->isValid();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon2D_paren__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon2D *arg1 = (iDynTree::Polygon2D *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Vector2 *result = 0 ;
  
  if (!SWIG_check_num_args("Polygon2D_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon2D_paren" "', argument " "1"" of type '" "iDynTree::Polygon2D *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon2D * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Polygon2D_paren" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (iDynTree::Vector2 *) &(arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_2_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon2D_paren__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon2D *arg1 = (iDynTree::Polygon2D *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  iDynTree::Vector2 *result = 0 ;
  
  if (!SWIG_check_num_args("Polygon2D_paren",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Polygon2D_paren" "', argument " "1"" of type '" "iDynTree::Polygon2D const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon2D * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Polygon2D_paren" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (iDynTree::Vector2 *) &((iDynTree::Polygon2D const *)arg1)->operator ()(arg2);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorFixSizeT_2_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_Polygon2D_paren(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Polygon2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Polygon2D_paren__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__Polygon2D, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Polygon2D_paren__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'Polygon2D_paren'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::Polygon2D::operator ()(size_t const)\n"
    "    iDynTree::Polygon2D::operator ()(size_t const) const\n");
  return 1;
}


int _wrap_delete_Polygon2D(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::Polygon2D *arg1 = (iDynTree::Polygon2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_Polygon2D",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__Polygon2D, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Polygon2D" "', argument " "1"" of type '" "iDynTree::Polygon2D *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::Polygon2D * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_setActive(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_setActive",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_setActive" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConvexHullProjectionConstraint_setActive" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setActive(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_isActive(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_isActive",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_isActive" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  result = (bool)(arg1)->isActive();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_getNrOfConstraints(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  size_t result;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_getNrOfConstraints",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_getNrOfConstraints" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  result = (arg1)->getNrOfConstraints();
  _out = SWIG_From_size_t(static_cast< size_t >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_projectedConvexHull_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  iDynTree::Polygon2D *arg2 = (iDynTree::Polygon2D *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_projectedConvexHull_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_projectedConvexHull_set" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__Polygon2D, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_projectedConvexHull_set" "', argument " "2"" of type '" "iDynTree::Polygon2D *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Polygon2D * >(argp2);
  if (arg1) (arg1)->projectedConvexHull = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_projectedConvexHull_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Polygon2D *result = 0 ;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_projectedConvexHull_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_projectedConvexHull_get" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  result = (iDynTree::Polygon2D *)& ((arg1)->projectedConvexHull);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Polygon2D, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_A_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  iDynTree::MatrixDynSize *arg2 = (iDynTree::MatrixDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_A_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_A_set" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_A_set" "', argument " "2"" of type '" "iDynTree::MatrixDynSize *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp2);
  if (arg1) (arg1)->A = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_A_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_A_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_A_get" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  result = (iDynTree::MatrixDynSize *)& ((arg1)->A);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_b_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  iDynTree::VectorDynSize *arg2 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_b_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_b_set" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_b_set" "', argument " "2"" of type '" "iDynTree::VectorDynSize *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  if (arg1) (arg1)->b = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_b_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::VectorDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_b_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_b_get" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  result = (iDynTree::VectorDynSize *)& ((arg1)->b);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_P_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  iDynTree::Matrix2x3 *arg2 = (iDynTree::Matrix2x3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_P_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_P_set" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_P_set" "', argument " "2"" of type '" "iDynTree::Matrix2x3 *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Matrix2x3 * >(argp2);
  if (arg1) (arg1)->P = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_P_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix2x3 *result = 0 ;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_P_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_P_get" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  result = (iDynTree::Matrix2x3 *)& ((arg1)->P);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_Pdirection_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  iDynTree::Matrix2x3 *arg2 = (iDynTree::Matrix2x3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_Pdirection_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_Pdirection_set" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_Pdirection_set" "', argument " "2"" of type '" "iDynTree::Matrix2x3 *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Matrix2x3 * >(argp2);
  if (arg1) (arg1)->Pdirection = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_Pdirection_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Matrix2x3 *result = 0 ;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_Pdirection_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_Pdirection_get" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  result = (iDynTree::Matrix2x3 *)& ((arg1)->Pdirection);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixFixSizeT_2_3_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_AtimesP_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  iDynTree::MatrixDynSize *arg2 = (iDynTree::MatrixDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_AtimesP_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_AtimesP_set" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_AtimesP_set" "', argument " "2"" of type '" "iDynTree::MatrixDynSize *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::MatrixDynSize * >(argp2);
  if (arg1) (arg1)->AtimesP = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_AtimesP_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::MatrixDynSize *result = 0 ;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_AtimesP_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_AtimesP_get" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  result = (iDynTree::MatrixDynSize *)& ((arg1)->AtimesP);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__MatrixDynSize, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_o_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  iDynTree::Position *arg2 = (iDynTree::Position *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_o_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_o_set" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_o_set" "', argument " "2"" of type '" "iDynTree::Position *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  if (arg1) (arg1)->o = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_o_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Position *result = 0 ;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_o_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_o_get" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  result = (iDynTree::Position *)& ((arg1)->o);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Position, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_buildConvexHull(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  iDynTree::Direction arg2 ;
  iDynTree::Direction arg3 ;
  iDynTree::Position arg4 ;
  std::vector< iDynTree::Polygon,std::allocator< iDynTree::Polygon > > *arg5 = 0 ;
  std::vector< iDynTree::Transform,std::allocator< iDynTree::Transform > > *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_buildConvexHull",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_buildConvexHull" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Direction,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_buildConvexHull" "', argument " "2"" of type '" "iDynTree::Direction const""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvexHullProjectionConstraint_buildConvexHull" "', argument " "2"" of type '" "iDynTree::Direction const""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Direction * >(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Direction,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvexHullProjectionConstraint_buildConvexHull" "', argument " "3"" of type '" "iDynTree::Direction const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvexHullProjectionConstraint_buildConvexHull" "', argument " "3"" of type '" "iDynTree::Direction const""'");
    } else {
      arg3 = *(reinterpret_cast< iDynTree::Direction * >(argp3));
    }
  }
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Position,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvexHullProjectionConstraint_buildConvexHull" "', argument " "4"" of type '" "iDynTree::Position const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvexHullProjectionConstraint_buildConvexHull" "', argument " "4"" of type '" "iDynTree::Position const""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::Position * >(argp4));
    }
  }
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_std__vectorT_iDynTree__Polygon_std__allocatorT_iDynTree__Polygon_t_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ConvexHullProjectionConstraint_buildConvexHull" "', argument " "5"" of type '" "std::vector< iDynTree::Polygon,std::allocator< iDynTree::Polygon > > const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvexHullProjectionConstraint_buildConvexHull" "', argument " "5"" of type '" "std::vector< iDynTree::Polygon,std::allocator< iDynTree::Polygon > > const &""'"); 
  }
  arg5 = reinterpret_cast< std::vector< iDynTree::Polygon,std::allocator< iDynTree::Polygon > > * >(argp5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_std__vectorT_iDynTree__Transform_std__allocatorT_iDynTree__Transform_t_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ConvexHullProjectionConstraint_buildConvexHull" "', argument " "6"" of type '" "std::vector< iDynTree::Transform,std::allocator< iDynTree::Transform > > const &""'"); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvexHullProjectionConstraint_buildConvexHull" "', argument " "6"" of type '" "std::vector< iDynTree::Transform,std::allocator< iDynTree::Transform > > const &""'"); 
  }
  arg6 = reinterpret_cast< std::vector< iDynTree::Transform,std::allocator< iDynTree::Transform > > * >(argp6);
  result = (bool)(arg1)->buildConvexHull(arg2,arg3,arg4,(std::vector< iDynTree::Polygon,std::allocator< iDynTree::Polygon > > const &)*arg5,(std::vector< iDynTree::Transform,std::allocator< iDynTree::Transform > > const &)*arg6);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_supportFrameIndices_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  std::vector< int,std::allocator< int > > *arg2 = (std::vector< int,std::allocator< int > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_supportFrameIndices_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_supportFrameIndices_set" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_supportFrameIndices_set" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (arg1) (arg1)->supportFrameIndices = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_supportFrameIndices_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_supportFrameIndices_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_supportFrameIndices_get" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  result = (std::vector< int,std::allocator< int > > *)& ((arg1)->supportFrameIndices);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_std__allocatorT_int_t_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_set(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  std::vector< iDynTree::Transform,std::allocator< iDynTree::Transform > > *arg2 = (std::vector< iDynTree::Transform,std::allocator< iDynTree::Transform > > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_set",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_set" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__vectorT_iDynTree__Transform_std__allocatorT_iDynTree__Transform_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_set" "', argument " "2"" of type '" "std::vector< iDynTree::Transform,std::allocator< iDynTree::Transform > > *""'"); 
  }
  arg2 = reinterpret_cast< std::vector< iDynTree::Transform,std::allocator< iDynTree::Transform > > * >(argp2);
  if (arg1) (arg1)->absoluteFrame_X_supportFrame = *arg2;
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_get(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::vector< iDynTree::Transform,std::allocator< iDynTree::Transform > > *result = 0 ;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_get",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_get" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  result = (std::vector< iDynTree::Transform,std::allocator< iDynTree::Transform > > *)& ((arg1)->absoluteFrame_X_supportFrame);
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_iDynTree__Transform_std__allocatorT_iDynTree__Transform_t_t, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_project(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  SwigValueWrapper< iDynTree::VectorFixSize< 2 > > result;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_project",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_project" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_project" "', argument " "2"" of type '" "iDynTree::Position &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvexHullProjectionConstraint_project" "', argument " "2"" of type '" "iDynTree::Position &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = (arg1)->project(*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Vector2(static_cast< const iDynTree::Vector2& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_2_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_computeMargin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  iDynTree::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_computeMargin",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_computeMargin" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_2_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_computeMargin" "', argument " "2"" of type '" "iDynTree::Vector2 const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvexHullProjectionConstraint_computeMargin" "', argument " "2"" of type '" "iDynTree::Vector2 const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Vector2 * >(argp2);
  result = (double)(arg1)->computeMargin((iDynTree::Vector2 const &)*arg2);
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_setProjectionAlongDirection(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  iDynTree::Vector3 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_setProjectionAlongDirection",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_setProjectionAlongDirection" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_setProjectionAlongDirection" "', argument " "2"" of type '" "iDynTree::Vector3""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvexHullProjectionConstraint_setProjectionAlongDirection" "', argument " "2"" of type '" "iDynTree::Vector3""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Vector3 * >(argp2));
    }
  }
  (arg1)->setProjectionAlongDirection(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_ConvexHullProjectionConstraint_projectAlongDirection(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  SwigValueWrapper< iDynTree::VectorFixSize< 2 > > result;
  
  if (!SWIG_check_num_args("ConvexHullProjectionConstraint_projectAlongDirection",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvexHullProjectionConstraint_projectAlongDirection" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvexHullProjectionConstraint_projectAlongDirection" "', argument " "2"" of type '" "iDynTree::Position &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvexHullProjectionConstraint_projectAlongDirection" "', argument " "2"" of type '" "iDynTree::Position &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  result = (arg1)->projectAlongDirection(*arg2);
  _out = SWIG_NewPointerObj((new iDynTree::Vector2(static_cast< const iDynTree::Vector2& >(result))), SWIGTYPE_p_iDynTree__VectorFixSizeT_2_t, SWIG_POINTER_OWN |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_ConvexHullProjectionConstraint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::ConvexHullProjectionConstraint *result = 0 ;
  
  if (!SWIG_check_num_args("new_ConvexHullProjectionConstraint",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::ConvexHullProjectionConstraint *)new iDynTree::ConvexHullProjectionConstraint();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_ConvexHullProjectionConstraint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::ConvexHullProjectionConstraint *arg1 = (iDynTree::ConvexHullProjectionConstraint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_ConvexHullProjectionConstraint",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__ConvexHullProjectionConstraint, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConvexHullProjectionConstraint" "', argument " "1"" of type '" "iDynTree::ConvexHullProjectionConstraint *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::ConvexHullProjectionConstraint * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_sizeOfRotationParametrization(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  enum iDynTree::InverseKinematicsRotationParametrization arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  mxArray * _out;
  int result;
  
  if (!SWIG_check_num_args("sizeOfRotationParametrization",argc,1,1,0)) {
    SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sizeOfRotationParametrization" "', argument " "1"" of type '" "enum iDynTree::InverseKinematicsRotationParametrization""'");
  } 
  arg1 = static_cast< enum iDynTree::InverseKinematicsRotationParametrization >(val1);
  result = (int)iDynTree::sizeOfRotationParametrization(arg1);
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_new_InverseKinematics(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  mxArray * _out;
  iDynTree::InverseKinematics *result = 0 ;
  
  if (!SWIG_check_num_args("new_InverseKinematics",argc,0,0,0)) {
    SWIG_fail;
  }
  (void)argv;
  result = (iDynTree::InverseKinematics *)new iDynTree::InverseKinematics();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__InverseKinematics, 1 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_delete_InverseKinematics(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  int is_owned;
  if (!SWIG_check_num_args("delete_InverseKinematics",argc,1,1,0)) {
    SWIG_fail;
  }
  is_owned = SWIG_Matlab_isOwned(argv[0]);
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InverseKinematics" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  if (is_owned) {
    delete arg1;
  }
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_loadModelFromFile__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::string *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_loadModelFromFile",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_loadModelFromFile" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_loadModelFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_loadModelFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_loadModelFromFile" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_loadModelFromFile" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InverseKinematics_loadModelFromFile" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_loadModelFromFile" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  result = (bool)(arg1)->loadModelFromFile((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3,(std::string const &)*arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return 1;
}


int _wrap_InverseKinematics_loadModelFromFile__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_loadModelFromFile",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_loadModelFromFile" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_loadModelFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_loadModelFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_loadModelFromFile" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_loadModelFromFile" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->loadModelFromFile((std::string const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_InverseKinematics_loadModelFromFile__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_loadModelFromFile",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_loadModelFromFile" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_loadModelFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_loadModelFromFile" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->loadModelFromFile((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_loadModelFromFile(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InverseKinematics_loadModelFromFile__SWIG_2(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_loadModelFromFile__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_InverseKinematics_loadModelFromFile__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_loadModelFromFile'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::loadModelFromFile(std::string const &,std::vector< std::string,std::allocator< std::string > > const &,std::string const &)\n"
    "    iDynTree::InverseKinematics::loadModelFromFile(std::string const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    iDynTree::InverseKinematics::loadModelFromFile(std::string const &)\n");
  return 1;
}


int _wrap_InverseKinematics_setModel__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setModel",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setModel" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setModel" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setModel" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_setModel" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setModel" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->setModel((iDynTree::Model const &)*arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 0;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return 1;
}


int _wrap_InverseKinematics_setModel__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::Model *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setModel",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setModel" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Model,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setModel" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setModel" "', argument " "2"" of type '" "iDynTree::Model const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Model * >(argp2);
  result = (bool)(arg1)->setModel((iDynTree::Model const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setModel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InverseKinematics_setModel__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Model, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_setModel__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_setModel'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::setModel(iDynTree::Model const &,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    iDynTree::InverseKinematics::setModel(iDynTree::Model const &)\n");
  return 1;
}


int _wrap_InverseKinematics_setJointLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setJointLimits",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setJointLimits" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setJointLimits" "', argument " "2"" of type '" "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setJointLimits" "', argument " "2"" of type '" "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > * >(argp2);
  result = (bool)(arg1)->setJointLimits(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_getJointLimits(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_getJointLimits",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_getJointLimits" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_getJointLimits" "', argument " "2"" of type '" "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_getJointLimits" "', argument " "2"" of type '" "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > * >(argp2);
  result = (bool)(arg1)->getJointLimits(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_clearProblem(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_clearProblem",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_clearProblem" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  (arg1)->clearProblem();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setFloatingBaseOnFrameNamed(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setFloatingBaseOnFrameNamed",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setFloatingBaseOnFrameNamed" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setFloatingBaseOnFrameNamed" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setFloatingBaseOnFrameNamed" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->setFloatingBaseOnFrameNamed((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_setCurrentRobotConfiguration(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setCurrentRobotConfiguration",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setCurrentRobotConfiguration" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setCurrentRobotConfiguration" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCurrentRobotConfiguration" "', argument " "2"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_setCurrentRobotConfiguration" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCurrentRobotConfiguration" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  result = (bool)(arg1)->setCurrentRobotConfiguration((iDynTree::Transform const &)*arg2,(iDynTree::VectorDynSize const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setJointConfiguration(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setJointConfiguration",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setJointConfiguration" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setJointConfiguration" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setJointConfiguration" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InverseKinematics_setJointConfiguration" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->setJointConfiguration((std::string const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_setRotationParametrization(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  enum iDynTree::InverseKinematicsRotationParametrization arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setRotationParametrization",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setRotationParametrization" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseKinematics_setRotationParametrization" "', argument " "2"" of type '" "enum iDynTree::InverseKinematicsRotationParametrization""'");
  } 
  arg2 = static_cast< enum iDynTree::InverseKinematicsRotationParametrization >(val2);
  (arg1)->setRotationParametrization(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_rotationParametrization(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  enum iDynTree::InverseKinematicsRotationParametrization result;
  
  if (!SWIG_check_num_args("InverseKinematics_rotationParametrization",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_rotationParametrization" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  result = (enum iDynTree::InverseKinematicsRotationParametrization)(arg1)->rotationParametrization();
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setMaxIterations(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setMaxIterations",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setMaxIterations" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseKinematics_setMaxIterations" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setMaxIterations(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_maxIterations(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  int result;
  
  if (!SWIG_check_num_args("InverseKinematics_maxIterations",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_maxIterations" "', argument " "1"" of type '" "iDynTree::InverseKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  result = (int)((iDynTree::InverseKinematics const *)arg1)->maxIterations();
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setMaxCPUTime(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setMaxCPUTime",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setMaxCPUTime" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseKinematics_setMaxCPUTime" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setMaxCPUTime(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_maxCPUTime(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("InverseKinematics_maxCPUTime",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_maxCPUTime" "', argument " "1"" of type '" "iDynTree::InverseKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  result = (double)((iDynTree::InverseKinematics const *)arg1)->maxCPUTime();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setCostTolerance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setCostTolerance",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setCostTolerance" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseKinematics_setCostTolerance" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setCostTolerance(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_costTolerance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("InverseKinematics_costTolerance",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_costTolerance" "', argument " "1"" of type '" "iDynTree::InverseKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  result = (double)((iDynTree::InverseKinematics const *)arg1)->costTolerance();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setConstraintsTolerance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setConstraintsTolerance",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setConstraintsTolerance" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseKinematics_setConstraintsTolerance" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setConstraintsTolerance(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_constraintsTolerance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("InverseKinematics_constraintsTolerance",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_constraintsTolerance" "', argument " "1"" of type '" "iDynTree::InverseKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  result = (double)((iDynTree::InverseKinematics const *)arg1)->constraintsTolerance();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setVerbosity(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setVerbosity",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setVerbosity" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseKinematics_setVerbosity" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->setVerbosity(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_linearSolverName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  std::string result;
  
  if (!SWIG_check_num_args("InverseKinematics_linearSolverName",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_linearSolverName" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  result = (arg1)->linearSolverName();
  _out = SWIG_From_std_string(static_cast< std::string >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setLinearSolverName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setLinearSolverName",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setLinearSolverName" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setLinearSolverName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setLinearSolverName" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  (arg1)->setLinearSolverName((std::string const &)*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addFrameConstraint__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addFrameConstraint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addFrameConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addFrameConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addFrameConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->addFrameConstraint((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addFrameConstraint__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addFrameConstraint",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addFrameConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addFrameConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addFrameConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addFrameConstraint" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addFrameConstraint" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)(arg1)->addFrameConstraint((std::string const &)*arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addFrameConstraint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InverseKinematics_addFrameConstraint__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_addFrameConstraint__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_addFrameConstraint'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::addFrameConstraint(std::string const &)\n"
    "    iDynTree::InverseKinematics::addFrameConstraint(std::string const &,iDynTree::Transform const &)\n");
  return 1;
}


int _wrap_InverseKinematics_addFramePositionConstraint__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Position *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addFramePositionConstraint",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addFramePositionConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addFramePositionConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addFramePositionConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addFramePositionConstraint" "', argument " "3"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addFramePositionConstraint" "', argument " "3"" of type '" "iDynTree::Position const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Position * >(argp3);
  result = (bool)(arg1)->addFramePositionConstraint((std::string const &)*arg2,(iDynTree::Position const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addFramePositionConstraint__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addFramePositionConstraint",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addFramePositionConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addFramePositionConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addFramePositionConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addFramePositionConstraint" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addFramePositionConstraint" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)(arg1)->addFramePositionConstraint((std::string const &)*arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addFramePositionConstraint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_addFramePositionConstraint__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_addFramePositionConstraint__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_addFramePositionConstraint'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::addFramePositionConstraint(std::string const &,iDynTree::Position const &)\n"
    "    iDynTree::InverseKinematics::addFramePositionConstraint(std::string const &,iDynTree::Transform const &)\n");
  return 1;
}


int _wrap_InverseKinematics_addFrameRotationConstraint__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Rotation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addFrameRotationConstraint",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addFrameRotationConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addFrameRotationConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addFrameRotationConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addFrameRotationConstraint" "', argument " "3"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addFrameRotationConstraint" "', argument " "3"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Rotation * >(argp3);
  result = (bool)(arg1)->addFrameRotationConstraint((std::string const &)*arg2,(iDynTree::Rotation const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addFrameRotationConstraint__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addFrameRotationConstraint",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addFrameRotationConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addFrameRotationConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addFrameRotationConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addFrameRotationConstraint" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addFrameRotationConstraint" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)(arg1)->addFrameRotationConstraint((std::string const &)*arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addFrameRotationConstraint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_addFrameRotationConstraint__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_addFrameRotationConstraint__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_addFrameRotationConstraint'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::addFrameRotationConstraint(std::string const &,iDynTree::Rotation const &)\n"
    "    iDynTree::InverseKinematics::addFrameRotationConstraint(std::string const &,iDynTree::Transform const &)\n");
  return 1;
}


int _wrap_InverseKinematics_activateFrameConstraint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_activateFrameConstraint",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_activateFrameConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_activateFrameConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_activateFrameConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_activateFrameConstraint" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_activateFrameConstraint" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)(arg1)->activateFrameConstraint((std::string const &)*arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_deactivateFrameConstraint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_deactivateFrameConstraint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_deactivateFrameConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_deactivateFrameConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_deactivateFrameConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->deactivateFrameConstraint((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_isFrameConstraintActive(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_isFrameConstraintActive",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_isFrameConstraintActive" "', argument " "1"" of type '" "iDynTree::InverseKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_isFrameConstraintActive" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_isFrameConstraintActive" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (bool)((iDynTree::InverseKinematics const *)arg1)->isFrameConstraintActive((std::string const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addCenterOfMassProjectionConstraint__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Polygon *arg3 = 0 ;
  iDynTree::Direction arg4 ;
  iDynTree::Direction arg5 ;
  iDynTree::Position arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addCenterOfMassProjectionConstraint",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Polygon,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "3"" of type '" "iDynTree::Polygon const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "3"" of type '" "iDynTree::Polygon const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Polygon * >(argp3);
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Direction,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "4"" of type '" "iDynTree::Direction const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "4"" of type '" "iDynTree::Direction const""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::Direction * >(argp4));
    }
  }
  {
    res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__Direction,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "5"" of type '" "iDynTree::Direction const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "5"" of type '" "iDynTree::Direction const""'");
    } else {
      arg5 = *(reinterpret_cast< iDynTree::Direction * >(argp5));
    }
  }
  {
    res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__Position,  0 );
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "6"" of type '" "iDynTree::Position const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "6"" of type '" "iDynTree::Position const""'");
    } else {
      arg6 = *(reinterpret_cast< iDynTree::Position * >(argp6));
    }
  }
  result = (bool)(arg1)->addCenterOfMassProjectionConstraint((std::string const &)*arg2,(iDynTree::Polygon const &)*arg3,arg4,arg5,arg6);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addCenterOfMassProjectionConstraint__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Polygon *arg3 = 0 ;
  iDynTree::Direction arg4 ;
  iDynTree::Direction arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addCenterOfMassProjectionConstraint",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Polygon,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "3"" of type '" "iDynTree::Polygon const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "3"" of type '" "iDynTree::Polygon const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Polygon * >(argp3);
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Direction,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "4"" of type '" "iDynTree::Direction const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "4"" of type '" "iDynTree::Direction const""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::Direction * >(argp4));
    }
  }
  {
    res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__Direction,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "5"" of type '" "iDynTree::Direction const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "5"" of type '" "iDynTree::Direction const""'");
    } else {
      arg5 = *(reinterpret_cast< iDynTree::Direction * >(argp5));
    }
  }
  result = (bool)(arg1)->addCenterOfMassProjectionConstraint((std::string const &)*arg2,(iDynTree::Polygon const &)*arg3,arg4,arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addCenterOfMassProjectionConstraint__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Polygon *arg3 = 0 ;
  std::string *arg4 = 0 ;
  iDynTree::Polygon *arg5 = 0 ;
  iDynTree::Direction arg6 ;
  iDynTree::Direction arg7 ;
  iDynTree::Position arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addCenterOfMassProjectionConstraint",argc,8,8,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Polygon,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "3"" of type '" "iDynTree::Polygon const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "3"" of type '" "iDynTree::Polygon const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Polygon * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__Polygon,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "5"" of type '" "iDynTree::Polygon const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "5"" of type '" "iDynTree::Polygon const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::Polygon * >(argp5);
  {
    res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__Direction,  0 );
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "6"" of type '" "iDynTree::Direction const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "6"" of type '" "iDynTree::Direction const""'");
    } else {
      arg6 = *(reinterpret_cast< iDynTree::Direction * >(argp6));
    }
  }
  {
    res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__Direction,  0 );
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "7"" of type '" "iDynTree::Direction const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "7"" of type '" "iDynTree::Direction const""'");
    } else {
      arg7 = *(reinterpret_cast< iDynTree::Direction * >(argp7));
    }
  }
  {
    res8 = SWIG_ConvertPtr(argv[7], &argp8, SWIGTYPE_p_iDynTree__Position,  0 );
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "8"" of type '" "iDynTree::Position const""'"); 
    }  
    if (!argp8) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "8"" of type '" "iDynTree::Position const""'");
    } else {
      arg8 = *(reinterpret_cast< iDynTree::Position * >(argp8));
    }
  }
  result = (bool)(arg1)->addCenterOfMassProjectionConstraint((std::string const &)*arg2,(iDynTree::Polygon const &)*arg3,(std::string const &)*arg4,(iDynTree::Polygon const &)*arg5,arg6,arg7,arg8);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return 1;
}


int _wrap_InverseKinematics_addCenterOfMassProjectionConstraint__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Polygon *arg3 = 0 ;
  std::string *arg4 = 0 ;
  iDynTree::Polygon *arg5 = 0 ;
  iDynTree::Direction arg6 ;
  iDynTree::Direction arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addCenterOfMassProjectionConstraint",argc,7,7,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Polygon,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "3"" of type '" "iDynTree::Polygon const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "3"" of type '" "iDynTree::Polygon const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Polygon * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "4"" of type '" "std::string const &""'"); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__Polygon,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "5"" of type '" "iDynTree::Polygon const &""'"); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "5"" of type '" "iDynTree::Polygon const &""'"); 
  }
  arg5 = reinterpret_cast< iDynTree::Polygon * >(argp5);
  {
    res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__Direction,  0 );
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "6"" of type '" "iDynTree::Direction const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "6"" of type '" "iDynTree::Direction const""'");
    } else {
      arg6 = *(reinterpret_cast< iDynTree::Direction * >(argp6));
    }
  }
  {
    res7 = SWIG_ConvertPtr(argv[6], &argp7, SWIGTYPE_p_iDynTree__Direction,  0 );
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "7"" of type '" "iDynTree::Direction const""'"); 
    }  
    if (!argp7) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "7"" of type '" "iDynTree::Direction const""'");
    } else {
      arg7 = *(reinterpret_cast< iDynTree::Direction * >(argp7));
    }
  }
  result = (bool)(arg1)->addCenterOfMassProjectionConstraint((std::string const &)*arg2,(iDynTree::Polygon const &)*arg3,(std::string const &)*arg4,(iDynTree::Polygon const &)*arg5,arg6,arg7);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return 1;
}


int _wrap_InverseKinematics_addCenterOfMassProjectionConstraint__SWIG_4(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< iDynTree::Polygon,std::allocator< iDynTree::Polygon > > *arg3 = 0 ;
  iDynTree::Direction arg4 ;
  iDynTree::Direction arg5 ;
  iDynTree::Position arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addCenterOfMassProjectionConstraint",argc,6,6,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res2 = swig::asptr(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_std__vectorT_iDynTree__Polygon_std__allocatorT_iDynTree__Polygon_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "3"" of type '" "std::vector< iDynTree::Polygon,std::allocator< iDynTree::Polygon > > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "3"" of type '" "std::vector< iDynTree::Polygon,std::allocator< iDynTree::Polygon > > const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< iDynTree::Polygon,std::allocator< iDynTree::Polygon > > * >(argp3);
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_iDynTree__Direction,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "4"" of type '" "iDynTree::Direction const""'"); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "4"" of type '" "iDynTree::Direction const""'");
    } else {
      arg4 = *(reinterpret_cast< iDynTree::Direction * >(argp4));
    }
  }
  {
    res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_iDynTree__Direction,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "5"" of type '" "iDynTree::Direction const""'"); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "5"" of type '" "iDynTree::Direction const""'");
    } else {
      arg5 = *(reinterpret_cast< iDynTree::Direction * >(argp5));
    }
  }
  {
    res6 = SWIG_ConvertPtr(argv[5], &argp6, SWIGTYPE_p_iDynTree__Position,  0 );
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "6"" of type '" "iDynTree::Position const""'"); 
    }  
    if (!argp6) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addCenterOfMassProjectionConstraint" "', argument " "6"" of type '" "iDynTree::Position const""'");
    } else {
      arg6 = *(reinterpret_cast< iDynTree::Position * >(argp6));
    }
  }
  result = (bool)(arg1)->addCenterOfMassProjectionConstraint((std::vector< std::string,std::allocator< std::string > > const &)*arg2,(std::vector< iDynTree::Polygon,std::allocator< iDynTree::Polygon > > const &)*arg3,arg4,arg5,arg6);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addCenterOfMassProjectionConstraint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Polygon, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_InverseKinematics_addCenterOfMassProjectionConstraint__SWIG_1(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Polygon, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_InverseKinematics_addCenterOfMassProjectionConstraint__SWIG_0(resc,resv,argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< std::string,std::allocator< std::string > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__vectorT_iDynTree__Polygon_std__allocatorT_iDynTree__Polygon_t_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_InverseKinematics_addCenterOfMassProjectionConstraint__SWIG_4(resc,resv,argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Polygon, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__Polygon, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_InverseKinematics_addCenterOfMassProjectionConstraint__SWIG_3(resc,resv,argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Polygon, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_iDynTree__Polygon, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_iDynTree__Direction, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_InverseKinematics_addCenterOfMassProjectionConstraint__SWIG_2(resc,resv,argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_addCenterOfMassProjectionConstraint'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::addCenterOfMassProjectionConstraint(std::string const &,iDynTree::Polygon const &,iDynTree::Direction const,iDynTree::Direction const,iDynTree::Position const)\n"
    "    iDynTree::InverseKinematics::addCenterOfMassProjectionConstraint(std::string const &,iDynTree::Polygon const &,iDynTree::Direction const,iDynTree::Direction const)\n"
    "    iDynTree::InverseKinematics::addCenterOfMassProjectionConstraint(std::string const &,iDynTree::Polygon const &,std::string const &,iDynTree::Polygon const &,iDynTree::Direction const,iDynTree::Direction const,iDynTree::Position const)\n"
    "    iDynTree::InverseKinematics::addCenterOfMassProjectionConstraint(std::string const &,iDynTree::Polygon const &,std::string const &,iDynTree::Polygon const &,iDynTree::Direction const,iDynTree::Direction const)\n"
    "    iDynTree::InverseKinematics::addCenterOfMassProjectionConstraint(std::vector< std::string,std::allocator< std::string > > const &,std::vector< iDynTree::Polygon,std::allocator< iDynTree::Polygon > > const &,iDynTree::Direction const,iDynTree::Direction const,iDynTree::Position const)\n");
  return 1;
}


int _wrap_InverseKinematics_getCenterOfMassProjectionMargin(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  double result;
  
  if (!SWIG_check_num_args("InverseKinematics_getCenterOfMassProjectionMargin",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_getCenterOfMassProjectionMargin" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  result = (double)(arg1)->getCenterOfMassProjectionMargin();
  _out = SWIG_From_double(static_cast< double >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_getCenterOfMassProjectConstraintConvexHull(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::Polygon2D *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_getCenterOfMassProjectConstraintConvexHull",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_getCenterOfMassProjectConstraintConvexHull" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Polygon2D,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_getCenterOfMassProjectConstraintConvexHull" "', argument " "2"" of type '" "iDynTree::Polygon2D &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_getCenterOfMassProjectConstraintConvexHull" "', argument " "2"" of type '" "iDynTree::Polygon2D &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Polygon2D * >(argp2);
  result = (bool)(arg1)->getCenterOfMassProjectConstraintConvexHull(*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_addTarget__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addTarget",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InverseKinematics_addTarget" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "InverseKinematics_addTarget" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (bool)(arg1)->addTarget((std::string const &)*arg2,(iDynTree::Transform const &)*arg3,arg4,arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addTarget__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addTarget",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InverseKinematics_addTarget" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->addTarget((std::string const &)*arg2,(iDynTree::Transform const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addTarget__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addTarget",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)(arg1)->addTarget((std::string const &)*arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addTarget(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_addTarget__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_InverseKinematics_addTarget__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_InverseKinematics_addTarget__SWIG_0(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_addTarget'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::addTarget(std::string const &,iDynTree::Transform const &,double const,double const)\n"
    "    iDynTree::InverseKinematics::addTarget(std::string const &,iDynTree::Transform const &,double const)\n"
    "    iDynTree::InverseKinematics::addTarget(std::string const &,iDynTree::Transform const &)\n");
  return 1;
}


int _wrap_InverseKinematics_addPositionTarget__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Position *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addPositionTarget",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addPositionTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addPositionTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addPositionTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addPositionTarget" "', argument " "3"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addPositionTarget" "', argument " "3"" of type '" "iDynTree::Position const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Position * >(argp3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InverseKinematics_addPositionTarget" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->addPositionTarget((std::string const &)*arg2,(iDynTree::Position const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addPositionTarget__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Position *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addPositionTarget",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addPositionTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addPositionTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addPositionTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addPositionTarget" "', argument " "3"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addPositionTarget" "', argument " "3"" of type '" "iDynTree::Position const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Position * >(argp3);
  result = (bool)(arg1)->addPositionTarget((std::string const &)*arg2,(iDynTree::Position const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addPositionTarget__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addPositionTarget",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addPositionTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addPositionTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addPositionTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addPositionTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addPositionTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InverseKinematics_addPositionTarget" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->addPositionTarget((std::string const &)*arg2,(iDynTree::Transform const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addPositionTarget__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addPositionTarget",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addPositionTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addPositionTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addPositionTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addPositionTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addPositionTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)(arg1)->addPositionTarget((std::string const &)*arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addPositionTarget(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_addPositionTarget__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_addPositionTarget__SWIG_3(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_InverseKinematics_addPositionTarget__SWIG_2(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_InverseKinematics_addPositionTarget__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_addPositionTarget'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::addPositionTarget(std::string const &,iDynTree::Position const &,double const)\n"
    "    iDynTree::InverseKinematics::addPositionTarget(std::string const &,iDynTree::Position const &)\n"
    "    iDynTree::InverseKinematics::addPositionTarget(std::string const &,iDynTree::Transform const &,double const)\n"
    "    iDynTree::InverseKinematics::addPositionTarget(std::string const &,iDynTree::Transform const &)\n");
  return 1;
}


int _wrap_InverseKinematics_addRotationTarget__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Rotation *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addRotationTarget",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addRotationTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addRotationTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addRotationTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addRotationTarget" "', argument " "3"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addRotationTarget" "', argument " "3"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Rotation * >(argp3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InverseKinematics_addRotationTarget" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->addRotationTarget((std::string const &)*arg2,(iDynTree::Rotation const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addRotationTarget__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Rotation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addRotationTarget",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addRotationTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addRotationTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addRotationTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addRotationTarget" "', argument " "3"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addRotationTarget" "', argument " "3"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Rotation * >(argp3);
  result = (bool)(arg1)->addRotationTarget((std::string const &)*arg2,(iDynTree::Rotation const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addRotationTarget__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addRotationTarget",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addRotationTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addRotationTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addRotationTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addRotationTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addRotationTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InverseKinematics_addRotationTarget" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->addRotationTarget((std::string const &)*arg2,(iDynTree::Transform const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addRotationTarget__SWIG_3(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_addRotationTarget",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_addRotationTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_addRotationTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addRotationTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_addRotationTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_addRotationTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)(arg1)->addRotationTarget((std::string const &)*arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_addRotationTarget(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_addRotationTarget__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_addRotationTarget__SWIG_3(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_InverseKinematics_addRotationTarget__SWIG_2(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_InverseKinematics_addRotationTarget__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_addRotationTarget'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::addRotationTarget(std::string const &,iDynTree::Rotation const &,double const)\n"
    "    iDynTree::InverseKinematics::addRotationTarget(std::string const &,iDynTree::Rotation const &)\n"
    "    iDynTree::InverseKinematics::addRotationTarget(std::string const &,iDynTree::Transform const &,double const)\n"
    "    iDynTree::InverseKinematics::addRotationTarget(std::string const &,iDynTree::Transform const &)\n");
  return 1;
}


int _wrap_InverseKinematics_updateTarget__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_updateTarget",argc,5,5,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_updateTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_updateTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_updateTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_updateTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_updateTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InverseKinematics_updateTarget" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "InverseKinematics_updateTarget" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  result = (bool)(arg1)->updateTarget((std::string const &)*arg2,(iDynTree::Transform const &)*arg3,arg4,arg5);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_updateTarget__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_updateTarget",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_updateTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_updateTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_updateTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_updateTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_updateTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InverseKinematics_updateTarget" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->updateTarget((std::string const &)*arg2,(iDynTree::Transform const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_updateTarget__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_updateTarget",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_updateTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_updateTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_updateTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_updateTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_updateTarget" "', argument " "3"" of type '" "iDynTree::Transform const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)(arg1)->updateTarget((std::string const &)*arg2,(iDynTree::Transform const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_updateTarget(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_updateTarget__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_InverseKinematics_updateTarget__SWIG_1(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Transform, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_double(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_InverseKinematics_updateTarget__SWIG_0(resc,resv,argc,argv);
            }
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_updateTarget'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::updateTarget(std::string const &,iDynTree::Transform const &,double const,double const)\n"
    "    iDynTree::InverseKinematics::updateTarget(std::string const &,iDynTree::Transform const &,double const)\n"
    "    iDynTree::InverseKinematics::updateTarget(std::string const &,iDynTree::Transform const &)\n");
  return 1;
}


int _wrap_InverseKinematics_updatePositionTarget__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Position *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_updatePositionTarget",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_updatePositionTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_updatePositionTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_updatePositionTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_updatePositionTarget" "', argument " "3"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_updatePositionTarget" "', argument " "3"" of type '" "iDynTree::Position const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Position * >(argp3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InverseKinematics_updatePositionTarget" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->updatePositionTarget((std::string const &)*arg2,(iDynTree::Position const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_updatePositionTarget__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Position *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_updatePositionTarget",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_updatePositionTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_updatePositionTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_updatePositionTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_updatePositionTarget" "', argument " "3"" of type '" "iDynTree::Position const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_updatePositionTarget" "', argument " "3"" of type '" "iDynTree::Position const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Position * >(argp3);
  result = (bool)(arg1)->updatePositionTarget((std::string const &)*arg2,(iDynTree::Position const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_updatePositionTarget(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_updatePositionTarget__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_InverseKinematics_updatePositionTarget__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_updatePositionTarget'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::updatePositionTarget(std::string const &,iDynTree::Position const &,double const)\n"
    "    iDynTree::InverseKinematics::updatePositionTarget(std::string const &,iDynTree::Position const &)\n");
  return 1;
}


int _wrap_InverseKinematics_updateRotationTarget__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Rotation *arg3 = 0 ;
  double arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_updateRotationTarget",argc,4,4,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_updateRotationTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_updateRotationTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_updateRotationTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_updateRotationTarget" "', argument " "3"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_updateRotationTarget" "', argument " "3"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Rotation * >(argp3);
  ecode4 = SWIG_AsVal_double(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InverseKinematics_updateRotationTarget" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  result = (bool)(arg1)->updateRotationTarget((std::string const &)*arg2,(iDynTree::Rotation const &)*arg3,arg4);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_updateRotationTarget__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Rotation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_updateRotationTarget",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_updateRotationTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_updateRotationTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_updateRotationTarget" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Rotation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_updateRotationTarget" "', argument " "3"" of type '" "iDynTree::Rotation const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_updateRotationTarget" "', argument " "3"" of type '" "iDynTree::Rotation const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Rotation * >(argp3);
  result = (bool)(arg1)->updateRotationTarget((std::string const &)*arg2,(iDynTree::Rotation const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_updateRotationTarget(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_updateRotationTarget__SWIG_1(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__Rotation, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_InverseKinematics_updateRotationTarget__SWIG_0(resc,resv,argc,argv);
          }
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_updateRotationTarget'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::updateRotationTarget(std::string const &,iDynTree::Rotation const &,double const)\n"
    "    iDynTree::InverseKinematics::updateRotationTarget(std::string const &,iDynTree::Rotation const &)\n");
  return 1;
}


int _wrap_InverseKinematics_setDefaultTargetResolutionMode(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  enum iDynTree::InverseKinematicsTreatTargetAsConstraint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setDefaultTargetResolutionMode",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setDefaultTargetResolutionMode" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseKinematics_setDefaultTargetResolutionMode" "', argument " "2"" of type '" "enum iDynTree::InverseKinematicsTreatTargetAsConstraint""'");
  } 
  arg2 = static_cast< enum iDynTree::InverseKinematicsTreatTargetAsConstraint >(val2);
  (arg1)->setDefaultTargetResolutionMode(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_defaultTargetResolutionMode(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  enum iDynTree::InverseKinematicsTreatTargetAsConstraint result;
  
  if (!SWIG_check_num_args("InverseKinematics_defaultTargetResolutionMode",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_defaultTargetResolutionMode" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  result = (enum iDynTree::InverseKinematicsTreatTargetAsConstraint)(arg1)->defaultTargetResolutionMode();
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setTargetResolutionMode(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  enum iDynTree::InverseKinematicsTreatTargetAsConstraint arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setTargetResolutionMode",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setTargetResolutionMode" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setTargetResolutionMode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setTargetResolutionMode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InverseKinematics_setTargetResolutionMode" "', argument " "3"" of type '" "enum iDynTree::InverseKinematicsTreatTargetAsConstraint""'");
  } 
  arg3 = static_cast< enum iDynTree::InverseKinematicsTreatTargetAsConstraint >(val3);
  result = (bool)(arg1)->setTargetResolutionMode((std::string const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_targetResolutionMode(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  mxArray * _out;
  enum iDynTree::InverseKinematicsTreatTargetAsConstraint result;
  
  if (!SWIG_check_num_args("InverseKinematics_targetResolutionMode",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_targetResolutionMode" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_targetResolutionMode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_targetResolutionMode" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  result = (enum iDynTree::InverseKinematicsTreatTargetAsConstraint)(arg1)->targetResolutionMode((std::string const &)*arg2);
  _out = SWIG_From_int(static_cast< int >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_setDesiredFullJointsConfiguration__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setDesiredFullJointsConfiguration",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setDesiredFullJointsConfiguration" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setDesiredFullJointsConfiguration" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setDesiredFullJointsConfiguration" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InverseKinematics_setDesiredFullJointsConfiguration" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->setDesiredFullJointsConfiguration((iDynTree::VectorDynSize const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setDesiredFullJointsConfiguration__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setDesiredFullJointsConfiguration",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setDesiredFullJointsConfiguration" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setDesiredFullJointsConfiguration" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setDesiredFullJointsConfiguration" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  result = (bool)(arg1)->setDesiredFullJointsConfiguration((iDynTree::VectorDynSize const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setDesiredFullJointsConfiguration__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setDesiredFullJointsConfiguration",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setDesiredFullJointsConfiguration" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setDesiredFullJointsConfiguration" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setDesiredFullJointsConfiguration" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_setDesiredFullJointsConfiguration" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setDesiredFullJointsConfiguration" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  result = (bool)(arg1)->setDesiredFullJointsConfiguration((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setDesiredFullJointsConfiguration(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InverseKinematics_setDesiredFullJointsConfiguration__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_setDesiredFullJointsConfiguration__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InverseKinematics_setDesiredFullJointsConfiguration__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_setDesiredFullJointsConfiguration'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::setDesiredFullJointsConfiguration(iDynTree::VectorDynSize const &,double)\n"
    "    iDynTree::InverseKinematics::setDesiredFullJointsConfiguration(iDynTree::VectorDynSize const &)\n"
    "    iDynTree::InverseKinematics::setDesiredFullJointsConfiguration(iDynTree::VectorDynSize const &,iDynTree::VectorDynSize const &)\n");
  return 1;
}


int _wrap_InverseKinematics_setDesiredReducedJointConfiguration__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setDesiredReducedJointConfiguration",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setDesiredReducedJointConfiguration" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setDesiredReducedJointConfiguration" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setDesiredReducedJointConfiguration" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InverseKinematics_setDesiredReducedJointConfiguration" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  result = (bool)(arg1)->setDesiredReducedJointConfiguration((iDynTree::VectorDynSize const &)*arg2,arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setDesiredReducedJointConfiguration__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setDesiredReducedJointConfiguration",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setDesiredReducedJointConfiguration" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setDesiredReducedJointConfiguration" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setDesiredReducedJointConfiguration" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  result = (bool)(arg1)->setDesiredReducedJointConfiguration((iDynTree::VectorDynSize const &)*arg2);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setDesiredReducedJointConfiguration__SWIG_2(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::VectorDynSize *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setDesiredReducedJointConfiguration",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setDesiredReducedJointConfiguration" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setDesiredReducedJointConfiguration" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setDesiredReducedJointConfiguration" "', argument " "2"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::VectorDynSize * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_setDesiredReducedJointConfiguration" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setDesiredReducedJointConfiguration" "', argument " "3"" of type '" "iDynTree::VectorDynSize const &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  result = (bool)(arg1)->setDesiredReducedJointConfiguration((iDynTree::VectorDynSize const &)*arg2,(iDynTree::VectorDynSize const &)*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setDesiredReducedJointConfiguration(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InverseKinematics_setDesiredReducedJointConfiguration__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_InverseKinematics_setDesiredReducedJointConfiguration__SWIG_2(resc,resv,argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__VectorDynSize, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InverseKinematics_setDesiredReducedJointConfiguration__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_setDesiredReducedJointConfiguration'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::setDesiredReducedJointConfiguration(iDynTree::VectorDynSize const &,double)\n"
    "    iDynTree::InverseKinematics::setDesiredReducedJointConfiguration(iDynTree::VectorDynSize const &)\n"
    "    iDynTree::InverseKinematics::setDesiredReducedJointConfiguration(iDynTree::VectorDynSize const &,iDynTree::VectorDynSize const &)\n");
  return 1;
}


int _wrap_InverseKinematics_setFullJointsInitialCondition(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::Transform *arg2 = (iDynTree::Transform *) 0 ;
  iDynTree::VectorDynSize *arg3 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setFullJointsInitialCondition",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setFullJointsInitialCondition" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setFullJointsInitialCondition" "', argument " "2"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_setFullJointsInitialCondition" "', argument " "3"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  result = (bool)(arg1)->setFullJointsInitialCondition((iDynTree::Transform const *)arg2,(iDynTree::VectorDynSize const *)arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setReducedInitialCondition(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::Transform *arg2 = (iDynTree::Transform *) 0 ;
  iDynTree::VectorDynSize *arg3 = (iDynTree::VectorDynSize *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_setReducedInitialCondition",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setReducedInitialCondition" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_iDynTree__Transform, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setReducedInitialCondition" "', argument " "2"" of type '" "iDynTree::Transform const *""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_iDynTree__VectorDynSize, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_setReducedInitialCondition" "', argument " "3"" of type '" "iDynTree::VectorDynSize const *""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  result = (bool)(arg1)->setReducedInitialCondition((iDynTree::Transform const *)arg2,(iDynTree::VectorDynSize const *)arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_solve(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_solve",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_solve" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  result = (bool)(arg1)->solve();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_getFullJointsSolution(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_getFullJointsSolution",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_getFullJointsSolution" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_getFullJointsSolution" "', argument " "2"" of type '" "iDynTree::Transform &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_getFullJointsSolution" "', argument " "2"" of type '" "iDynTree::Transform &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_getFullJointsSolution" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_getFullJointsSolution" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  (arg1)->getFullJointsSolution(*arg2,*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_getReducedSolution(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::Transform *arg2 = 0 ;
  iDynTree::VectorDynSize *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_getReducedSolution",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_getReducedSolution" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_getReducedSolution" "', argument " "2"" of type '" "iDynTree::Transform &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_getReducedSolution" "', argument " "2"" of type '" "iDynTree::Transform &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Transform * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__VectorDynSize,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_getReducedSolution" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_getReducedSolution" "', argument " "3"" of type '" "iDynTree::VectorDynSize &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::VectorDynSize * >(argp3);
  (arg1)->getReducedSolution(*arg2,*arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_getPoseForFrame(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  std::string *arg2 = 0 ;
  iDynTree::Transform *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_getPoseForFrame",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_getPoseForFrame" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_getPoseForFrame" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_getPoseForFrame" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_iDynTree__Transform,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseKinematics_getPoseForFrame" "', argument " "3"" of type '" "iDynTree::Transform &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_getPoseForFrame" "', argument " "3"" of type '" "iDynTree::Transform &""'"); 
  }
  arg3 = reinterpret_cast< iDynTree::Transform * >(argp3);
  result = (bool)(arg1)->getPoseForFrame((std::string const &)*arg2,*arg3);
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 0;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return 1;
}


int _wrap_InverseKinematics_fullModel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Model *result = 0 ;
  
  if (!SWIG_check_num_args("InverseKinematics_fullModel",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_fullModel" "', argument " "1"" of type '" "iDynTree::InverseKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  result = (iDynTree::Model *) &((iDynTree::InverseKinematics const *)arg1)->fullModel();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_reducedModel(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  iDynTree::Model *result = 0 ;
  
  if (!SWIG_check_num_args("InverseKinematics_reducedModel",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_reducedModel" "', argument " "1"" of type '" "iDynTree::InverseKinematics const *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  result = (iDynTree::Model *) &((iDynTree::InverseKinematics const *)arg1)->reducedModel();
  _out = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_iDynTree__Model, 0 |  0 );
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setCOMTarget__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setCOMTarget",argc,3,3,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setCOMTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Position &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Position &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  ecode3 = SWIG_AsVal_double(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InverseKinematics_setCOMTarget" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  (arg1)->setCOMTarget(*arg2,arg3);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setCOMTarget__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::Position *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setCOMTarget",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setCOMTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__Position,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Position &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCOMTarget" "', argument " "2"" of type '" "iDynTree::Position &""'"); 
  }
  arg2 = reinterpret_cast< iDynTree::Position * >(argp2);
  (arg1)->setCOMTarget(*arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setCOMTarget(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InverseKinematics_setCOMTarget__SWIG_1(resc,resv,argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_iDynTree__Position, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InverseKinematics_setCOMTarget__SWIG_0(resc,resv,argc,argv);
        }
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_setCOMTarget'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::setCOMTarget(iDynTree::Position &,double)\n"
    "    iDynTree::InverseKinematics::setCOMTarget(iDynTree::Position &)\n");
  return 1;
}


int _wrap_InverseKinematics_setCOMAsConstraint__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setCOMAsConstraint",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setCOMAsConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseKinematics_setCOMAsConstraint" "', argument " "2"" of type '" "bool""'");
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setCOMAsConstraint(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setCOMAsConstraint__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setCOMAsConstraint",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setCOMAsConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  (arg1)->setCOMAsConstraint();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setCOMAsConstraint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_InverseKinematics_setCOMAsConstraint__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_InverseKinematics_setCOMAsConstraint__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_setCOMAsConstraint'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::setCOMAsConstraint(bool)\n"
    "    iDynTree::InverseKinematics::setCOMAsConstraint()\n");
  return 1;
}


int _wrap_InverseKinematics_setCOMAsConstraintTolerance__SWIG_0(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setCOMAsConstraintTolerance",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setCOMAsConstraintTolerance" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  ecode2 = SWIG_AsVal_double(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseKinematics_setCOMAsConstraintTolerance" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  (arg1)->setCOMAsConstraintTolerance(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setCOMAsConstraintTolerance__SWIG_1(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setCOMAsConstraintTolerance",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setCOMAsConstraintTolerance" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  (arg1)->setCOMAsConstraintTolerance();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setCOMAsConstraintTolerance(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_InverseKinematics_setCOMAsConstraintTolerance__SWIG_1(resc,resv,argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_iDynTree__InverseKinematics, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_InverseKinematics_setCOMAsConstraintTolerance__SWIG_0(resc,resv,argc,argv);
      }
    }
  }
  
  SWIG_Error(SWIG_RuntimeError, "No matching function for overload function 'InverseKinematics_setCOMAsConstraintTolerance'."
    "  Possible C/C++ prototypes are:\n"
    "    iDynTree::InverseKinematics::setCOMAsConstraintTolerance(double)\n"
    "    iDynTree::InverseKinematics::setCOMAsConstraintTolerance()\n");
  return 1;
}


int _wrap_InverseKinematics_isCOMAConstraint(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_isCOMAConstraint",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_isCOMAConstraint" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  result = (bool)(arg1)->isCOMAConstraint();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_isCOMTargetActive(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  bool result;
  
  if (!SWIG_check_num_args("InverseKinematics_isCOMTargetActive",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_isCOMTargetActive" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  result = (bool)(arg1)->isCOMTargetActive();
  _out = SWIG_From_bool(static_cast< bool >(result));
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_deactivateCOMTarget(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_deactivateCOMTarget",argc,1,1,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_deactivateCOMTarget" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  (arg1)->deactivateCOMTarget();
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}


int _wrap_InverseKinematics_setCOMConstraintProjectionDirection(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  iDynTree::InverseKinematics *arg1 = (iDynTree::InverseKinematics *) 0 ;
  iDynTree::Vector3 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  mxArray * _out;
  
  if (!SWIG_check_num_args("InverseKinematics_setCOMConstraintProjectionDirection",argc,2,2,0)) {
    SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_iDynTree__InverseKinematics, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseKinematics_setCOMConstraintProjectionDirection" "', argument " "1"" of type '" "iDynTree::InverseKinematics *""'"); 
  }
  arg1 = reinterpret_cast< iDynTree::InverseKinematics * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_iDynTree__VectorFixSizeT_3_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseKinematics_setCOMConstraintProjectionDirection" "', argument " "2"" of type '" "iDynTree::Vector3""'"); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseKinematics_setCOMConstraintProjectionDirection" "', argument " "2"" of type '" "iDynTree::Vector3""'");
    } else {
      arg2 = *(reinterpret_cast< iDynTree::Vector3 * >(argp2));
    }
  }
  (arg1)->setCOMConstraintProjectionDirection(arg2);
  _out = (mxArray*)0;
  if (_out) --resc, *resv++ = _out;
  return 0;
fail:
  return 1;
}



/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_iDynTree__ClassicalAccTo_p_iDynTree__VectorFixSizeT_6_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::VectorFixSize< 6 > *)  ((iDynTree::ClassicalAcc *) x));
}
static void *_p_iDynTree__PixelVizTo_p_iDynTree__ColorViz(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::ColorViz *)  ((iDynTree::PixelViz *) x));
}
static void *_p_iDynTree__AttitudeMahonyFilterTo_p_iDynTree__IAttitudeEstimator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::IAttitudeEstimator *)  ((iDynTree::AttitudeMahonyFilter *) x));
}
static void *_p_iDynTree__AttitudeQuaternionEKFTo_p_iDynTree__IAttitudeEstimator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::IAttitudeEstimator *)  ((iDynTree::AttitudeQuaternionEKF *) x));
}
static void *_p_iDynTree__RotationTo_p_iDynTree__RotationRaw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::RotationRaw *)  ((iDynTree::Rotation *) x));
}
static void *_p_iDynTree__PositionTo_p_iDynTree__PositionRaw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::PositionRaw *)  ((iDynTree::Position *) x));
}
static void *_p_iDynTree__RevoluteJointTo_p_iDynTree__MovableJointImplT_1_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::MovableJointImpl< 1,1 > *)  ((iDynTree::RevoluteJoint *) x));
}
static void *_p_iDynTree__PrismaticJointTo_p_iDynTree__MovableJointImplT_1_1_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::MovableJointImpl< 1,1 > *)  ((iDynTree::PrismaticJoint *) x));
}
static void *_p_iDynTree__PositionTo_p_iDynTree__VectorFixSizeT_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::VectorFixSize< 3 > *) (iDynTree::PositionRaw *) ((iDynTree::Position *) x));
}
static void *_p_iDynTree__PositionRawTo_p_iDynTree__VectorFixSizeT_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::VectorFixSize< 3 > *)  ((iDynTree::PositionRaw *) x));
}
static void *_p_iDynTree__GeomVector3To_p_iDynTree__VectorFixSizeT_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::VectorFixSize< 3 > *)  ((iDynTree::GeomVector3 *) x));
}
static void *_p_iDynTree__DirectionTo_p_iDynTree__VectorFixSizeT_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::VectorFixSize< 3 > *)  ((iDynTree::Direction *) x));
}
static void *_p_iDynTree__FrameFreeFloatingJacobianTo_p_iDynTree__MatrixDynSize(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::MatrixDynSize *)  ((iDynTree::FrameFreeFloatingJacobian *) x));
}
static void *_p_iDynTree__MomentumFreeFloatingJacobianTo_p_iDynTree__MatrixDynSize(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::MatrixDynSize *)  ((iDynTree::MomentumFreeFloatingJacobian *) x));
}
static void *_p_iDynTree__FreeFloatingMassMatrixTo_p_iDynTree__MatrixDynSize(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::MatrixDynSize *)  ((iDynTree::FreeFloatingMassMatrix *) x));
}
static void *_p_iDynTree__JointPosDoubleArrayTo_p_iDynTree__VectorDynSize(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::VectorDynSize *)  ((iDynTree::JointPosDoubleArray *) x));
}
static void *_p_iDynTree__JointDOFsDoubleArrayTo_p_iDynTree__VectorDynSize(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::VectorDynSize *)  ((iDynTree::JointDOFsDoubleArray *) x));
}
static void *_p_iDynTree__WrenchTo_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) (iDynTree::SpatialForceVector *) ((iDynTree::Wrench *) x));
}
static void *_p_iDynTree__SpatialForceVectorTo_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SpatialVector< iDynTree::SpatialForceVector > *)  ((iDynTree::SpatialForceVector *) x));
}
static void *_p_iDynTree__SpatialMomentumTo_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SpatialVector< iDynTree::SpatialForceVector > *) (iDynTree::SpatialForceVector *) ((iDynTree::SpatialMomentum *) x));
}
static void *_p_iDynTree__SixAxisForceTorqueSensorTo_p_iDynTree__JointSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::JointSensor *)  ((iDynTree::SixAxisForceTorqueSensor *) x));
}
static void *_p_iDynTree__JointSensorTo_p_iDynTree__Sensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::Sensor *)  ((iDynTree::JointSensor *) x));
}
static void *_p_iDynTree__AccelerometerSensorTo_p_iDynTree__Sensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::Sensor *) (iDynTree::LinkSensor *) ((iDynTree::AccelerometerSensor *) x));
}
static void *_p_iDynTree__ThreeAxisAngularAccelerometerSensorTo_p_iDynTree__Sensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::Sensor *) (iDynTree::LinkSensor *) ((iDynTree::ThreeAxisAngularAccelerometerSensor *) x));
}
static void *_p_iDynTree__ThreeAxisForceTorqueContactSensorTo_p_iDynTree__Sensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::Sensor *) (iDynTree::LinkSensor *) ((iDynTree::ThreeAxisForceTorqueContactSensor *) x));
}
static void *_p_iDynTree__LinkSensorTo_p_iDynTree__Sensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::Sensor *)  ((iDynTree::LinkSensor *) x));
}
static void *_p_iDynTree__SixAxisForceTorqueSensorTo_p_iDynTree__Sensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::Sensor *) (iDynTree::JointSensor *) ((iDynTree::SixAxisForceTorqueSensor *) x));
}
static void *_p_iDynTree__GyroscopeSensorTo_p_iDynTree__Sensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::Sensor *) (iDynTree::LinkSensor *) ((iDynTree::GyroscopeSensor *) x));
}
static void *_p_iDynTree__BoxTo_p_iDynTree__SolidShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SolidShape *)  ((iDynTree::Box *) x));
}
static void *_p_iDynTree__ExternalMeshTo_p_iDynTree__SolidShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SolidShape *)  ((iDynTree::ExternalMesh *) x));
}
static void *_p_iDynTree__SphereTo_p_iDynTree__SolidShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SolidShape *)  ((iDynTree::Sphere *) x));
}
static void *_p_iDynTree__CylinderTo_p_iDynTree__SolidShape(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SolidShape *)  ((iDynTree::Cylinder *) x));
}
static void *_p_iDynTree__SpatialInertiaTo_p_iDynTree__SpatialInertiaRaw(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SpatialInertiaRaw *)  ((iDynTree::SpatialInertia *) x));
}
static void *_p_iDynTree__AccelerometerSensorTo_p_iDynTree__LinkSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::LinkSensor *)  ((iDynTree::AccelerometerSensor *) x));
}
static void *_p_iDynTree__ThreeAxisAngularAccelerometerSensorTo_p_iDynTree__LinkSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::LinkSensor *)  ((iDynTree::ThreeAxisAngularAccelerometerSensor *) x));
}
static void *_p_iDynTree__ThreeAxisForceTorqueContactSensorTo_p_iDynTree__LinkSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::LinkSensor *)  ((iDynTree::ThreeAxisForceTorqueContactSensor *) x));
}
static void *_p_iDynTree__GyroscopeSensorTo_p_iDynTree__LinkSensor(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::LinkSensor *)  ((iDynTree::GyroscopeSensor *) x));
}
static void *_p_iDynTree__TwistTo_p_iDynTree__SpatialMotionVector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SpatialMotionVector *)  ((iDynTree::Twist *) x));
}
static void *_p_iDynTree__SpatialAccTo_p_iDynTree__SpatialMotionVector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SpatialMotionVector *)  ((iDynTree::SpatialAcc *) x));
}
static void *_p_iDynTree__WrenchTo_p_iDynTree__SpatialForceVector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SpatialForceVector *)  ((iDynTree::Wrench *) x));
}
static void *_p_iDynTree__SpatialMomentumTo_p_iDynTree__SpatialForceVector(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SpatialForceVector *)  ((iDynTree::SpatialMomentum *) x));
}
static void *_p_iDynTree__RotationalInertiaRawTo_p_iDynTree__MatrixFixSizeT_3_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::MatrixFixSize< 3,3 > *)  ((iDynTree::RotationalInertiaRaw *) x));
}
static void *_p_iDynTree__RotationRawTo_p_iDynTree__MatrixFixSizeT_3_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::MatrixFixSize< 3,3 > *)  ((iDynTree::RotationRaw *) x));
}
static void *_p_iDynTree__RotationTo_p_iDynTree__MatrixFixSizeT_3_3_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::MatrixFixSize< 3,3 > *) (iDynTree::RotationRaw *) ((iDynTree::Rotation *) x));
}
static void *_p_iDynTree__MovableJointImplT_1_1_tTo_p_iDynTree__IJoint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::IJoint *)  ((iDynTree::MovableJointImpl< 1,1 > *) x));
}
static void *_p_iDynTree__RevoluteJointTo_p_iDynTree__IJoint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::IJoint *) (iDynTree::MovableJointImpl< 1,1 > *) ((iDynTree::RevoluteJoint *) x));
}
static void *_p_iDynTree__MovableJointImplT_6_6_tTo_p_iDynTree__IJoint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::IJoint *)  ((iDynTree::MovableJointImpl< 6,6 > *) x));
}
static void *_p_iDynTree__MovableJointImplT_5_5_tTo_p_iDynTree__IJoint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::IJoint *)  ((iDynTree::MovableJointImpl< 5,5 > *) x));
}
static void *_p_iDynTree__PrismaticJointTo_p_iDynTree__IJoint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::IJoint *) (iDynTree::MovableJointImpl< 1,1 > *) ((iDynTree::PrismaticJoint *) x));
}
static void *_p_iDynTree__MovableJointImplT_4_4_tTo_p_iDynTree__IJoint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::IJoint *)  ((iDynTree::MovableJointImpl< 4,4 > *) x));
}
static void *_p_iDynTree__FixedJointTo_p_iDynTree__IJoint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::IJoint *)  ((iDynTree::FixedJoint *) x));
}
static void *_p_iDynTree__MovableJointImplT_3_3_tTo_p_iDynTree__IJoint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::IJoint *)  ((iDynTree::MovableJointImpl< 3,3 > *) x));
}
static void *_p_iDynTree__MovableJointImplT_2_2_tTo_p_iDynTree__IJoint(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::IJoint *)  ((iDynTree::MovableJointImpl< 2,2 > *) x));
}
static void *_p_iDynTree__AttitudeQuaternionEKFTo_p_iDynTree__DiscreteExtendedKalmanFilterHelper(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::DiscreteExtendedKalmanFilterHelper *)  ((iDynTree::AttitudeQuaternionEKF *) x));
}
static void *_p_iDynTree__SpatialMotionVectorTo_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *)  ((iDynTree::SpatialMotionVector *) x));
}
static void *_p_iDynTree__TwistTo_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) (iDynTree::SpatialMotionVector *) ((iDynTree::Twist *) x));
}
static void *_p_iDynTree__SpatialAccTo_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *) (iDynTree::SpatialMotionVector *) ((iDynTree::SpatialAcc *) x));
}
static swig_type_info _swigt__p_AngularVector3T = {"_p_AngularVector3T", "AngularVector3T *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_DualVectorT = {"_p_DualVectorT", "DualVectorT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_LinearVector3T = {"_p_LinearVector3T", "LinearVector3T *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Type = {"_p_Type", "Type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_iterator = {"_p_const_iterator", "const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_pointer = {"_p_const_pointer", "const_pointer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_reference = {"_p_const_reference", "const_reference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_reverse_iterator = {"_p_const_reverse_iterator", "const_reverse_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_const_typed_iterator = {"_p_const_typed_iterator", "const_typed_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "iDynTree::Span< double,-1 >::element_type *|iDynTree::MatrixView< double >::element_type *|iDynTree::Span< double,-1 >::pointer|iDynTree::MatrixView< double >::pointer|double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_element_type = {"_p_element_type", "element_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__AccelerometerSensor = {"_p_iDynTree__AccelerometerSensor", "iDynTree::AccelerometerSensor *", 0, 0, (void*)"iDynTree.AccelerometerSensor", 0};
static swig_type_info _swigt__p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers = {"_p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers", "iDynTree::ArticulatedBodyAlgorithmInternalBuffers *", 0, 0, (void*)"iDynTree.ArticulatedBodyAlgorithmInternalBuffers", 0};
static swig_type_info _swigt__p_iDynTree__ArticulatedBodyInertia = {"_p_iDynTree__ArticulatedBodyInertia", "iDynTree::ArticulatedBodyInertia *", 0, 0, (void*)"iDynTree.ArticulatedBodyInertia", 0};
static swig_type_info _swigt__p_iDynTree__AttitudeEstimatorState = {"_p_iDynTree__AttitudeEstimatorState", "iDynTree::AttitudeEstimatorState *", 0, 0, (void*)"iDynTree.AttitudeEstimatorState", 0};
static swig_type_info _swigt__p_iDynTree__AttitudeMahonyFilter = {"_p_iDynTree__AttitudeMahonyFilter", "iDynTree::AttitudeMahonyFilter *", 0, 0, (void*)"iDynTree.AttitudeMahonyFilter", 0};
static swig_type_info _swigt__p_iDynTree__AttitudeMahonyFilterParameters = {"_p_iDynTree__AttitudeMahonyFilterParameters", "iDynTree::AttitudeMahonyFilterParameters *", 0, 0, (void*)"iDynTree.AttitudeMahonyFilterParameters", 0};
static swig_type_info _swigt__p_iDynTree__AttitudeQuaternionEKF = {"_p_iDynTree__AttitudeQuaternionEKF", "iDynTree::AttitudeQuaternionEKF *", 0, 0, (void*)"iDynTree.AttitudeQuaternionEKF", 0};
static swig_type_info _swigt__p_iDynTree__AttitudeQuaternionEKFParameters = {"_p_iDynTree__AttitudeQuaternionEKFParameters", "iDynTree::AttitudeQuaternionEKFParameters *", 0, 0, (void*)"iDynTree.AttitudeQuaternionEKFParameters", 0};
static swig_type_info _swigt__p_iDynTree__Axis = {"_p_iDynTree__Axis", "iDynTree::Axis *", 0, 0, (void*)"iDynTree.Axis", 0};
static swig_type_info _swigt__p_iDynTree__BerdyDynamicVariable = {"_p_iDynTree__BerdyDynamicVariable", "std::vector< iDynTree::BerdyDynamicVariable >::value_type *|iDynTree::BerdyDynamicVariable *", 0, 0, (void*)"iDynTree.BerdyDynamicVariable", 0};
static swig_type_info _swigt__p_iDynTree__BerdyHelper = {"_p_iDynTree__BerdyHelper", "iDynTree::BerdyHelper *", 0, 0, (void*)"iDynTree.BerdyHelper", 0};
static swig_type_info _swigt__p_iDynTree__BerdyOptions = {"_p_iDynTree__BerdyOptions", "iDynTree::BerdyOptions *", 0, 0, (void*)"iDynTree.BerdyOptions", 0};
static swig_type_info _swigt__p_iDynTree__BerdySensor = {"_p_iDynTree__BerdySensor", "std::vector< iDynTree::BerdySensor >::value_type *|iDynTree::BerdySensor *", 0, 0, (void*)"iDynTree.BerdySensor", 0};
static swig_type_info _swigt__p_iDynTree__BerdySparseMAPSolver = {"_p_iDynTree__BerdySparseMAPSolver", "iDynTree::BerdySparseMAPSolver *", 0, 0, (void*)"iDynTree.BerdySparseMAPSolver", 0};
static swig_type_info _swigt__p_iDynTree__Box = {"_p_iDynTree__Box", "iDynTree::Box *", 0, 0, (void*)"iDynTree.Box", 0};
static swig_type_info _swigt__p_iDynTree__ClassicalAcc = {"_p_iDynTree__ClassicalAcc", "iDynTree::ClassicalAcc *", 0, 0, (void*)"iDynTree.ClassicalAcc", 0};
static swig_type_info _swigt__p_iDynTree__ColorViz = {"_p_iDynTree__ColorViz", "iDynTree::ColorViz *", 0, 0, (void*)"iDynTree.ColorViz", 0};
static swig_type_info _swigt__p_iDynTree__ContactWrench = {"_p_iDynTree__ContactWrench", "iDynTree::ContactWrench *", 0, 0, (void*)"iDynTree.ContactWrench", 0};
static swig_type_info _swigt__p_iDynTree__ConvexHullProjectionConstraint = {"_p_iDynTree__ConvexHullProjectionConstraint", "iDynTree::ConvexHullProjectionConstraint *", 0, 0, (void*)"iDynTree.ConvexHullProjectionConstraint", 0};
static swig_type_info _swigt__p_iDynTree__Cylinder = {"_p_iDynTree__Cylinder", "iDynTree::Cylinder *", 0, 0, (void*)"iDynTree.Cylinder", 0};
static swig_type_info _swigt__p_iDynTree__DOFSpatialForceArray = {"_p_iDynTree__DOFSpatialForceArray", "iDynTree::DOFSpatialForceArray *", 0, 0, (void*)"iDynTree.DOFSpatialForceArray", 0};
static swig_type_info _swigt__p_iDynTree__DOFSpatialMotionArray = {"_p_iDynTree__DOFSpatialMotionArray", "iDynTree::DOFSpatialMotionArray *", 0, 0, (void*)"iDynTree.DOFSpatialMotionArray", 0};
static swig_type_info _swigt__p_iDynTree__Direction = {"_p_iDynTree__Direction", "iDynTree::Direction *", 0, 0, (void*)"iDynTree.Direction", 0};
static swig_type_info _swigt__p_iDynTree__DiscreteExtendedKalmanFilterHelper = {"_p_iDynTree__DiscreteExtendedKalmanFilterHelper", "iDynTree::DiscreteExtendedKalmanFilterHelper *", 0, 0, (void*)"iDynTree.DiscreteExtendedKalmanFilterHelper", 0};
static swig_type_info _swigt__p_iDynTree__Dummy = {"_p_iDynTree__Dummy", "iDynTree::Dummy *", 0, 0, (void*)"iDynTree.Dummy", 0};
static swig_type_info _swigt__p_iDynTree__ExtWrenchesAndJointTorquesEstimator = {"_p_iDynTree__ExtWrenchesAndJointTorquesEstimator", "iDynTree::ExtWrenchesAndJointTorquesEstimator *", 0, 0, (void*)"iDynTree.ExtWrenchesAndJointTorquesEstimator", 0};
static swig_type_info _swigt__p_iDynTree__ExternalMesh = {"_p_iDynTree__ExternalMesh", "iDynTree::ExternalMesh *", 0, 0, (void*)"iDynTree.ExternalMesh", 0};
static swig_type_info _swigt__p_iDynTree__FixedJoint = {"_p_iDynTree__FixedJoint", "iDynTree::FixedJoint *", 0, 0, (void*)"iDynTree.FixedJoint", 0};
static swig_type_info _swigt__p_iDynTree__FrameFreeFloatingJacobian = {"_p_iDynTree__FrameFreeFloatingJacobian", "iDynTree::FrameFreeFloatingJacobian *", 0, 0, (void*)"iDynTree.FrameFreeFloatingJacobian", 0};
static swig_type_info _swigt__p_iDynTree__FreeFloatingAcc = {"_p_iDynTree__FreeFloatingAcc", "iDynTree::FreeFloatingAcc *", 0, 0, (void*)"iDynTree.FreeFloatingAcc", 0};
static swig_type_info _swigt__p_iDynTree__FreeFloatingGeneralizedTorques = {"_p_iDynTree__FreeFloatingGeneralizedTorques", "iDynTree::FreeFloatingGeneralizedTorques *", 0, 0, (void*)"iDynTree.FreeFloatingGeneralizedTorques", 0};
static swig_type_info _swigt__p_iDynTree__FreeFloatingMassMatrix = {"_p_iDynTree__FreeFloatingMassMatrix", "iDynTree::FreeFloatingMassMatrix *", 0, 0, (void*)"iDynTree.FreeFloatingMassMatrix", 0};
static swig_type_info _swigt__p_iDynTree__FreeFloatingPos = {"_p_iDynTree__FreeFloatingPos", "iDynTree::FreeFloatingPos *", 0, 0, (void*)"iDynTree.FreeFloatingPos", 0};
static swig_type_info _swigt__p_iDynTree__FreeFloatingVel = {"_p_iDynTree__FreeFloatingVel", "iDynTree::FreeFloatingVel *", 0, 0, (void*)"iDynTree.FreeFloatingVel", 0};
static swig_type_info _swigt__p_iDynTree__GeomVector3 = {"_p_iDynTree__GeomVector3", "iDynTree::LinMomentum *|iDynTree::AngMomentum *|iDynTree::LinAcceleration *|iDynTree::AngAcceleration *|iDynTree::Force *|iDynTree::LinVelocity *|iDynTree::AngVelocity *|iDynTree::Torque *|iDynTree::MotionVector3 *|iDynTree::AngularForceVector3 *|iDynTree::LinearForceVector3 *|iDynTree::LinearMotionVector3 *|iDynTree::AngularMotionVector3 *|iDynTree::GeomVector3 *", 0, 0, (void*)"iDynTree.GeomVector3", 0};
static swig_type_info _swigt__p_iDynTree__GyroscopeSensor = {"_p_iDynTree__GyroscopeSensor", "iDynTree::GyroscopeSensor *", 0, 0, (void*)"iDynTree.GyroscopeSensor", 0};
static swig_type_info _swigt__p_iDynTree__IAttitudeEstimator = {"_p_iDynTree__IAttitudeEstimator", "iDynTree::IAttitudeEstimator *", 0, 0, (void*)"iDynTree.IAttitudeEstimator", 0};
static swig_type_info _swigt__p_iDynTree__ICamera = {"_p_iDynTree__ICamera", "iDynTree::ICamera *", 0, 0, (void*)"iDynTree.ICamera", 0};
static swig_type_info _swigt__p_iDynTree__ICameraAnimator = {"_p_iDynTree__ICameraAnimator", "iDynTree::ICameraAnimator *", 0, 0, (void*)"iDynTree.ICameraAnimator", 0};
static swig_type_info _swigt__p_iDynTree__IEnvironment = {"_p_iDynTree__IEnvironment", "iDynTree::IEnvironment *", 0, 0, (void*)"iDynTree.IEnvironment", 0};
static swig_type_info _swigt__p_iDynTree__IFrameVisualization = {"_p_iDynTree__IFrameVisualization", "iDynTree::IFrameVisualization *", 0, 0, (void*)"iDynTree.IFrameVisualization", 0};
static swig_type_info _swigt__p_iDynTree__IJetsVisualization = {"_p_iDynTree__IJetsVisualization", "iDynTree::IJetsVisualization *", 0, 0, (void*)"iDynTree.IJetsVisualization", 0};
static swig_type_info _swigt__p_iDynTree__IJoint = {"_p_iDynTree__IJoint", "iDynTree::IJointPtr|iDynTree::IJoint *|iDynTree::IJointConstPtr", 0, 0, (void*)"iDynTree.IJoint", 0};
static swig_type_info _swigt__p_iDynTree__ILight = {"_p_iDynTree__ILight", "iDynTree::ILight *", 0, 0, (void*)"iDynTree.ILight", 0};
static swig_type_info _swigt__p_iDynTree__IModelVisualization = {"_p_iDynTree__IModelVisualization", "iDynTree::IModelVisualization *", 0, 0, (void*)"iDynTree.IModelVisualization", 0};
static swig_type_info _swigt__p_iDynTree__ITexture = {"_p_iDynTree__ITexture", "iDynTree::ITexture *", 0, 0, (void*)"iDynTree.ITexture", 0};
static swig_type_info _swigt__p_iDynTree__ITexturesHandler = {"_p_iDynTree__ITexturesHandler", "iDynTree::ITexturesHandler *", 0, 0, (void*)"iDynTree.ITexturesHandler", 0};
static swig_type_info _swigt__p_iDynTree__IVectorsVisualization = {"_p_iDynTree__IVectorsVisualization", "iDynTree::IVectorsVisualization *", 0, 0, (void*)"iDynTree.IVectorsVisualization", 0};
static swig_type_info _swigt__p_iDynTree__IndexRange = {"_p_iDynTree__IndexRange", "iDynTree::IndexRange *", 0, 0, (void*)"iDynTree.IndexRange", 0};
static swig_type_info _swigt__p_iDynTree__InverseKinematics = {"_p_iDynTree__InverseKinematics", "iDynTree::InverseKinematics *", 0, 0, (void*)"iDynTree.InverseKinematics", 0};
static swig_type_info _swigt__p_iDynTree__JointDOFsDoubleArray = {"_p_iDynTree__JointDOFsDoubleArray", "iDynTree::JointDOFsDoubleArray *", 0, 0, (void*)"iDynTree.JointDOFsDoubleArray", 0};
static swig_type_info _swigt__p_iDynTree__JointPosDoubleArray = {"_p_iDynTree__JointPosDoubleArray", "iDynTree::JointPosDoubleArray *", 0, 0, (void*)"iDynTree.JointPosDoubleArray", 0};
static swig_type_info _swigt__p_iDynTree__JointSensor = {"_p_iDynTree__JointSensor", "iDynTree::JointSensor *", 0, 0, (void*)"iDynTree.JointSensor", 0};
static swig_type_info _swigt__p_iDynTree__KinDynComputations = {"_p_iDynTree__KinDynComputations", "iDynTree::KinDynComputations *", 0, 0, (void*)"iDynTree.KinDynComputations", 0};
static swig_type_info _swigt__p_iDynTree__Link = {"_p_iDynTree__Link", "iDynTree::Link *|iDynTree::LinkPtr|iDynTree::LinkConstPtr", 0, 0, (void*)"iDynTree.Link", 0};
static swig_type_info _swigt__p_iDynTree__LinkAccArray = {"_p_iDynTree__LinkAccArray", "iDynTree::LinkAccArray *|iDynTree::LinkProperAccArray *", 0, 0, (void*)"iDynTree.LinkAccArray", 0};
static swig_type_info _swigt__p_iDynTree__LinkArticulatedBodyInertias = {"_p_iDynTree__LinkArticulatedBodyInertias", "iDynTree::LinkArticulatedBodyInertias *", 0, 0, (void*)"iDynTree.LinkArticulatedBodyInertias", 0};
static swig_type_info _swigt__p_iDynTree__LinkContactWrenches = {"_p_iDynTree__LinkContactWrenches", "iDynTree::LinkContactWrenches *", 0, 0, (void*)"iDynTree.LinkContactWrenches", 0};
static swig_type_info _swigt__p_iDynTree__LinkInertias = {"_p_iDynTree__LinkInertias", "iDynTree::LinkInertias *|iDynTree::LinkCompositeRigidBodyInertias *", 0, 0, (void*)"iDynTree.LinkInertias", 0};
static swig_type_info _swigt__p_iDynTree__LinkPositions = {"_p_iDynTree__LinkPositions", "iDynTree::LinkPositions *", 0, 0, (void*)"iDynTree.LinkPositions", 0};
static swig_type_info _swigt__p_iDynTree__LinkSensor = {"_p_iDynTree__LinkSensor", "iDynTree::LinkSensor *", 0, 0, (void*)"iDynTree.LinkSensor", 0};
static swig_type_info _swigt__p_iDynTree__LinkUnknownWrenchContacts = {"_p_iDynTree__LinkUnknownWrenchContacts", "iDynTree::LinkUnknownWrenchContacts *", 0, 0, (void*)"iDynTree.LinkUnknownWrenchContacts", 0};
static swig_type_info _swigt__p_iDynTree__LinkVelArray = {"_p_iDynTree__LinkVelArray", "iDynTree::LinkVelArray *", 0, 0, (void*)"iDynTree.LinkVelArray", 0};
static swig_type_info _swigt__p_iDynTree__LinkWrenches = {"_p_iDynTree__LinkWrenches", "iDynTree::LinkWrenches *|iDynTree::LinkNetExternalWrenches *|iDynTree::LinkInternalWrenches *|iDynTree::LinkNetTotalWrenchesWithoutGravity *", 0, 0, (void*)"iDynTree.LinkWrenches", 0};
static swig_type_info _swigt__p_iDynTree__Material = {"_p_iDynTree__Material", "iDynTree::Material *", 0, 0, (void*)"iDynTree.Material", 0};
static swig_type_info _swigt__p_iDynTree__MatrixDynSize = {"_p_iDynTree__MatrixDynSize", "iDynTree::MatrixDynSize *", 0, 0, (void*)"iDynTree.MatrixDynSize", 0};
static swig_type_info _swigt__p_iDynTree__MatrixFixSizeT_10_16_t = {"_p_iDynTree__MatrixFixSizeT_10_16_t", "iDynTree::MatrixFixSize< 10,16 > *|iDynTree::Matrix10x16 *", 0, 0, (void*)"iDynTree.Matrix10x16", 0};
static swig_type_info _swigt__p_iDynTree__MatrixFixSizeT_1_6_t = {"_p_iDynTree__MatrixFixSizeT_1_6_t", "iDynTree::Matrix1x6 *|iDynTree::MatrixFixSize< 1,6 > *", 0, 0, (void*)"iDynTree.Matrix1x6", 0};
static swig_type_info _swigt__p_iDynTree__MatrixFixSizeT_2_3_t = {"_p_iDynTree__MatrixFixSizeT_2_3_t", "iDynTree::MatrixFixSize< 2,3 > *|iDynTree::Matrix2x3 *", 0, 0, (void*)"iDynTree.Matrix2x3", 0};
static swig_type_info _swigt__p_iDynTree__MatrixFixSizeT_3_3_t = {"_p_iDynTree__MatrixFixSizeT_3_3_t", "iDynTree::Matrix3x3 *|iDynTree::MatrixFixSize< 3,3 > *", 0, 0, (void*)"iDynTree.Matrix3x3", 0};
static swig_type_info _swigt__p_iDynTree__MatrixFixSizeT_3_4_t = {"_p_iDynTree__MatrixFixSizeT_3_4_t", "iDynTree::MatrixFixSize< 3,4 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__MatrixFixSizeT_4_3_t = {"_p_iDynTree__MatrixFixSizeT_4_3_t", "iDynTree::MatrixFixSize< 4,3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__MatrixFixSizeT_4_4_t = {"_p_iDynTree__MatrixFixSizeT_4_4_t", "std::vector< iDynTree::MatrixFixSize< 4,4 > >::value_type *|iDynTree::MatrixFixSize< 4,4 > *|iDynTree::Matrix4x4 *", 0, 0, (void*)"iDynTree.Matrix4x4", 0};
static swig_type_info _swigt__p_iDynTree__MatrixFixSizeT_6_10_t = {"_p_iDynTree__MatrixFixSizeT_6_10_t", "iDynTree::MatrixFixSize< 6,10 > *|iDynTree::Matrix6x10 *", 0, 0, (void*)"iDynTree.Matrix6x10", 0};
static swig_type_info _swigt__p_iDynTree__MatrixFixSizeT_6_1_t = {"_p_iDynTree__MatrixFixSizeT_6_1_t", "iDynTree::MatrixFixSize< 6,1 > *|iDynTree::Matrix6x1 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__MatrixFixSizeT_6_6_t = {"_p_iDynTree__MatrixFixSizeT_6_6_t", "iDynTree::MatrixFixSize< 6,6 > *|iDynTree::Matrix6x6 *", 0, 0, (void*)"iDynTree.Matrix6x6", 0};
static swig_type_info _swigt__p_iDynTree__MatrixViewT_double_const_t = {"_p_iDynTree__MatrixViewT_double_const_t", "iDynTree::MatrixView< double const > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__MatrixViewT_double_t = {"_p_iDynTree__MatrixViewT_double_t", "iDynTree::MatrixView< double > *", 0, 0, (void*)"iDynTree.DynamicMatrixView", 0};
static swig_type_info _swigt__p_iDynTree__Model = {"_p_iDynTree__Model", "iDynTree::Model *", 0, 0, (void*)"iDynTree.Model", 0};
static swig_type_info _swigt__p_iDynTree__ModelCalibrationHelper = {"_p_iDynTree__ModelCalibrationHelper", "iDynTree::ModelCalibrationHelper *", 0, 0, (void*)"iDynTree.ModelCalibrationHelper", 0};
static swig_type_info _swigt__p_iDynTree__ModelExporter = {"_p_iDynTree__ModelExporter", "iDynTree::ModelExporter *", 0, 0, (void*)"iDynTree.ModelExporter", 0};
static swig_type_info _swigt__p_iDynTree__ModelExporterOptions = {"_p_iDynTree__ModelExporterOptions", "iDynTree::ModelExporterOptions *", 0, 0, (void*)"iDynTree.ModelExporterOptions", 0};
static swig_type_info _swigt__p_iDynTree__ModelLoader = {"_p_iDynTree__ModelLoader", "iDynTree::ModelLoader *", 0, 0, (void*)"iDynTree.ModelLoader", 0};
static swig_type_info _swigt__p_iDynTree__ModelParserOptions = {"_p_iDynTree__ModelParserOptions", "iDynTree::ModelParserOptions *", 0, 0, (void*)"iDynTree.ModelParserOptions", 0};
static swig_type_info _swigt__p_iDynTree__ModelSolidShapes = {"_p_iDynTree__ModelSolidShapes", "iDynTree::ModelSolidShapes *", 0, 0, (void*)"iDynTree.ModelSolidShapes", 0};
static swig_type_info _swigt__p_iDynTree__MomentumFreeFloatingJacobian = {"_p_iDynTree__MomentumFreeFloatingJacobian", "iDynTree::MomentumFreeFloatingJacobian *", 0, 0, (void*)"iDynTree.MomentumFreeFloatingJacobian", 0};
static swig_type_info _swigt__p_iDynTree__MovableJointImplT_1_1_t = {"_p_iDynTree__MovableJointImplT_1_1_t", "iDynTree::MovableJointImpl< 1,1 > *|iDynTree::MovableJointImpl1 *", 0, 0, (void*)"iDynTree.MovableJointImpl1", 0};
static swig_type_info _swigt__p_iDynTree__MovableJointImplT_2_2_t = {"_p_iDynTree__MovableJointImplT_2_2_t", "iDynTree::MovableJointImpl< 2,2 > *|iDynTree::MovableJointImpl2 *", 0, 0, (void*)"iDynTree.MovableJointImpl2", 0};
static swig_type_info _swigt__p_iDynTree__MovableJointImplT_3_3_t = {"_p_iDynTree__MovableJointImplT_3_3_t", "iDynTree::MovableJointImpl3 *|iDynTree::MovableJointImpl< 3,3 > *", 0, 0, (void*)"iDynTree.MovableJointImpl3", 0};
static swig_type_info _swigt__p_iDynTree__MovableJointImplT_4_4_t = {"_p_iDynTree__MovableJointImplT_4_4_t", "iDynTree::MovableJointImpl4 *|iDynTree::MovableJointImpl< 4,4 > *", 0, 0, (void*)"iDynTree.MovableJointImpl4", 0};
static swig_type_info _swigt__p_iDynTree__MovableJointImplT_5_5_t = {"_p_iDynTree__MovableJointImplT_5_5_t", "iDynTree::MovableJointImpl< 5,5 > *|iDynTree::MovableJointImpl5 *", 0, 0, (void*)"iDynTree.MovableJointImpl5", 0};
static swig_type_info _swigt__p_iDynTree__MovableJointImplT_6_6_t = {"_p_iDynTree__MovableJointImplT_6_6_t", "iDynTree::MovableJointImpl< 6,6 > *|iDynTree::MovableJointImpl6 *", 0, 0, (void*)"iDynTree.MovableJointImpl6", 0};
static swig_type_info _swigt__p_iDynTree__Neighbor = {"_p_iDynTree__Neighbor", "iDynTree::Neighbor *", 0, 0, (void*)"iDynTree.Neighbor", 0};
static swig_type_info _swigt__p_iDynTree__PixelViz = {"_p_iDynTree__PixelViz", "iDynTree::PixelViz *", 0, 0, (void*)"iDynTree.PixelViz", 0};
static swig_type_info _swigt__p_iDynTree__Polygon = {"_p_iDynTree__Polygon", "iDynTree::Polygon *", 0, 0, (void*)"iDynTree.Polygon", 0};
static swig_type_info _swigt__p_iDynTree__Polygon2D = {"_p_iDynTree__Polygon2D", "iDynTree::Polygon2D *", 0, 0, (void*)"iDynTree.Polygon2D", 0};
static swig_type_info _swigt__p_iDynTree__Position = {"_p_iDynTree__Position", "iDynTree::Position *", 0, 0, (void*)"iDynTree.Position", 0};
static swig_type_info _swigt__p_iDynTree__PositionRaw = {"_p_iDynTree__PositionRaw", "iDynTree::PositionRaw *", 0, 0, (void*)"iDynTree.PositionRaw", 0};
static swig_type_info _swigt__p_iDynTree__PrismaticJoint = {"_p_iDynTree__PrismaticJoint", "iDynTree::PrismaticJoint *", 0, 0, (void*)"iDynTree.PrismaticJoint", 0};
static swig_type_info _swigt__p_iDynTree__RevoluteJoint = {"_p_iDynTree__RevoluteJoint", "iDynTree::RevoluteJoint *", 0, 0, (void*)"iDynTree.RevoluteJoint", 0};
static swig_type_info _swigt__p_iDynTree__RigidBodyInertiaNonLinearParametrization = {"_p_iDynTree__RigidBodyInertiaNonLinearParametrization", "iDynTree::RigidBodyInertiaNonLinearParametrization *", 0, 0, (void*)"iDynTree.RigidBodyInertiaNonLinearParametrization", 0};
static swig_type_info _swigt__p_iDynTree__Rotation = {"_p_iDynTree__Rotation", "iDynTree::Rotation *", 0, 0, (void*)"iDynTree.Rotation", 0};
static swig_type_info _swigt__p_iDynTree__RotationRaw = {"_p_iDynTree__RotationRaw", "iDynTree::RotationRaw *", 0, 0, (void*)"iDynTree.RotationRaw", 0};
static swig_type_info _swigt__p_iDynTree__RotationalInertiaRaw = {"_p_iDynTree__RotationalInertiaRaw", "iDynTree::RotationalInertiaRaw *", 0, 0, (void*)"iDynTree.RotationalInertiaRaw", 0};
static swig_type_info _swigt__p_iDynTree__Sensor = {"_p_iDynTree__Sensor", "iDynTree::Sensor *", 0, 0, (void*)"iDynTree.Sensor", 0};
static swig_type_info _swigt__p_iDynTree__SensorsList = {"_p_iDynTree__SensorsList", "iDynTree::SensorsList *", 0, 0, (void*)"iDynTree.SensorsList", 0};
static swig_type_info _swigt__p_iDynTree__SensorsMeasurements = {"_p_iDynTree__SensorsMeasurements", "iDynTree::SensorsMeasurements *", 0, 0, (void*)"iDynTree.SensorsMeasurements", 0};
static swig_type_info _swigt__p_iDynTree__SimpleLeggedOdometry = {"_p_iDynTree__SimpleLeggedOdometry", "iDynTree::SimpleLeggedOdometry *", 0, 0, (void*)"iDynTree.SimpleLeggedOdometry", 0};
static swig_type_info _swigt__p_iDynTree__SixAxisForceTorqueSensor = {"_p_iDynTree__SixAxisForceTorqueSensor", "iDynTree::SixAxisForceTorqueSensor *", 0, 0, (void*)"iDynTree.SixAxisForceTorqueSensor", 0};
static swig_type_info _swigt__p_iDynTree__SolidShape = {"_p_iDynTree__SolidShape", "std::vector< iDynTree::SolidShape * >::value_type|iDynTree::SolidShape *", 0, 0, (void*)"iDynTree.SolidShape", 0};
static swig_type_info _swigt__p_iDynTree__SpanT_double__1_t = {"_p_iDynTree__SpanT_double__1_t", "iDynTree::Span< iDynTree::Span< double,-1 >::element_type,-1 > *|iDynTree::Span< double,-1 > *", 0, 0, (void*)"iDynTree.DynamicSpan", 0};
static swig_type_info _swigt__p_iDynTree__SpanT_double_const__1_t = {"_p_iDynTree__SpanT_double_const__1_t", "iDynTree::Span< double const,-1 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t = {"_p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t", "iDynTree::SparseMatrix< iDynTree::ColumnMajor > *", 0, 0, (void*)"iDynTree.SparseMatrixColMajor", 0};
static swig_type_info _swigt__p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t = {"_p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t", "iDynTree::SparseMatrix< iDynTree::RowMajor > *", 0, 0, (void*)"iDynTree.SparseMatrixRowMajor", 0};
static swig_type_info _swigt__p_iDynTree__SpatialAcc = {"_p_iDynTree__SpatialAcc", "iDynTree::SpatialAcc *", 0, 0, (void*)"iDynTree.SpatialAcc", 0};
static swig_type_info _swigt__p_iDynTree__SpatialForceVector = {"_p_iDynTree__SpatialForceVector", "iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::DualVectorT *|iDynTree::SpatialForceVector *", 0, 0, (void*)"iDynTree.SpatialForceVector", 0};
static swig_type_info _swigt__p_iDynTree__SpatialInertia = {"_p_iDynTree__SpatialInertia", "iDynTree::SpatialInertia *", 0, 0, (void*)"iDynTree.SpatialInertia", 0};
static swig_type_info _swigt__p_iDynTree__SpatialInertiaRaw = {"_p_iDynTree__SpatialInertiaRaw", "iDynTree::SpatialInertiaRaw *", 0, 0, (void*)"iDynTree.SpatialInertiaRaw", 0};
static swig_type_info _swigt__p_iDynTree__SpatialMomentum = {"_p_iDynTree__SpatialMomentum", "iDynTree::SpatialMomentum *", 0, 0, (void*)"iDynTree.SpatialMomentum", 0};
static swig_type_info _swigt__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type = {"_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type", "iDynTree::SpatialForceVector::AngularVector3T *|iDynTree::SpatialMotionForceVectorT_traits< iDynTree::SpatialForceVector >::AngularVector3Type *|iDynTree::SpatialVector< iDynTree::SpatialForceVector >::AngularVector3T *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type = {"_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type", "iDynTree::SpatialForceVector::LinearVector3T *|iDynTree::SpatialMotionForceVectorT_traits< iDynTree::SpatialForceVector >::LinearVector3Type *|iDynTree::SpatialVector< iDynTree::SpatialForceVector >::LinearVector3T *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__AngularVector3Type = {"_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__AngularVector3Type", "iDynTree::SpatialMotionForceVectorT_traits< iDynTree::SpatialMotionVector >::AngularVector3Type *|iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::AngularVector3T *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__LinearVector3Type = {"_p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__LinearVector3Type", "iDynTree::SpatialMotionForceVectorT_traits< iDynTree::SpatialMotionVector >::LinearVector3Type *|iDynTree::SpatialVector< iDynTree::SpatialMotionVector >::LinearVector3T *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__SpatialMotionVector = {"_p_iDynTree__SpatialMotionVector", "iDynTree::SpatialVector< iDynTree::SpatialForceVector >::DualVectorT *|iDynTree::SpatialMotionVector *", 0, 0, (void*)"iDynTree.SpatialMotionVector", 0};
static swig_type_info _swigt__p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t = {"_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t", "iDynTree::SpatialVector< iDynTree::SpatialForceVector > *", 0, 0, (void*)"iDynTree.SpatialForceVectorBase", 0};
static swig_type_info _swigt__p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t = {"_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t", "iDynTree::SpatialVector< iDynTree::SpatialMotionVector > *", 0, 0, (void*)"iDynTree.SpatialMotionVectorBase", 0};
static swig_type_info _swigt__p_iDynTree__Sphere = {"_p_iDynTree__Sphere", "iDynTree::Sphere *", 0, 0, (void*)"iDynTree.Sphere", 0};
static swig_type_info _swigt__p_iDynTree__SubModelDecomposition = {"_p_iDynTree__SubModelDecomposition", "iDynTree::SubModelDecomposition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__ThreeAxisAngularAccelerometerSensor = {"_p_iDynTree__ThreeAxisAngularAccelerometerSensor", "iDynTree::ThreeAxisAngularAccelerometerSensor *", 0, 0, (void*)"iDynTree.ThreeAxisAngularAccelerometerSensor", 0};
static swig_type_info _swigt__p_iDynTree__ThreeAxisForceTorqueContactSensor = {"_p_iDynTree__ThreeAxisForceTorqueContactSensor", "iDynTree::ThreeAxisForceTorqueContactSensor *", 0, 0, (void*)"iDynTree.ThreeAxisForceTorqueContactSensor", 0};
static swig_type_info _swigt__p_iDynTree__Transform = {"_p_iDynTree__Transform", "iDynTree::Transform *", 0, 0, (void*)"iDynTree.Transform", 0};
static swig_type_info _swigt__p_iDynTree__TransformDerivative = {"_p_iDynTree__TransformDerivative", "iDynTree::TransformDerivative *", 0, 0, (void*)"iDynTree.TransformDerivative", 0};
static swig_type_info _swigt__p_iDynTree__Traversal = {"_p_iDynTree__Traversal", "iDynTree::Traversal *", 0, 0, (void*)"iDynTree.Traversal", 0};
static swig_type_info _swigt__p_iDynTree__Triplets = {"_p_iDynTree__Triplets", "iDynTree::Triplets *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__Twist = {"_p_iDynTree__Twist", "iDynTree::Twist *", 0, 0, (void*)"iDynTree.Twist", 0};
static swig_type_info _swigt__p_iDynTree__UnknownWrenchContact = {"_p_iDynTree__UnknownWrenchContact", "iDynTree::UnknownWrenchContact *", 0, 0, (void*)"iDynTree.UnknownWrenchContact", 0};
static swig_type_info _swigt__p_iDynTree__VectorDynSize = {"_p_iDynTree__VectorDynSize", "iDynTree::VectorDynSize *", 0, 0, (void*)"iDynTree.VectorDynSize", 0};
static swig_type_info _swigt__p_iDynTree__VectorFixSizeT_10_t = {"_p_iDynTree__VectorFixSizeT_10_t", "iDynTree::VectorFixSize< 10 > *|iDynTree::Vector10 *", 0, 0, (void*)"iDynTree.Vector10", 0};
static swig_type_info _swigt__p_iDynTree__VectorFixSizeT_16_t = {"_p_iDynTree__VectorFixSizeT_16_t", "iDynTree::Vector16 *|iDynTree::VectorFixSize< 16 > *", 0, 0, (void*)"iDynTree.Vector16", 0};
static swig_type_info _swigt__p_iDynTree__VectorFixSizeT_2_t = {"_p_iDynTree__VectorFixSizeT_2_t", "iDynTree::Vector2 *|iDynTree::VectorFixSize< 2 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__VectorFixSizeT_3_t = {"_p_iDynTree__VectorFixSizeT_3_t", "iDynTree::MagnetometerMeasurements *|iDynTree::GyroscopeMeasurements *|iDynTree::LinearAccelerometerMeasurements *|iDynTree::Vector3 *|iDynTree::RPY *|iDynTree::VectorFixSize< 3 > *", 0, 0, (void*)"iDynTree.Vector3", 0};
static swig_type_info _swigt__p_iDynTree__VectorFixSizeT_4_t = {"_p_iDynTree__VectorFixSizeT_4_t", "iDynTree::VectorFixSize< 4 > *|iDynTree::Vector4 *|iDynTree::UnitQuaternion *", 0, 0, (void*)"iDynTree.Vector4", 0};
static swig_type_info _swigt__p_iDynTree__VectorFixSizeT_6_t = {"_p_iDynTree__VectorFixSizeT_6_t", "iDynTree::Vector6 *|iDynTree::VectorFixSize< 6 > *", 0, 0, (void*)"iDynTree.Vector6", 0};
static swig_type_info _swigt__p_iDynTree__Visualizer = {"_p_iDynTree__Visualizer", "iDynTree::Visualizer *", 0, 0, (void*)"iDynTree.Visualizer", 0};
static swig_type_info _swigt__p_iDynTree__VisualizerOptions = {"_p_iDynTree__VisualizerOptions", "iDynTree::VisualizerOptions *", 0, 0, (void*)"iDynTree.VisualizerOptions", 0};
static swig_type_info _swigt__p_iDynTree__Wrench = {"_p_iDynTree__Wrench", "iDynTree::Wrench *", 0, 0, (void*)"iDynTree.Wrench", 0};
static swig_type_info _swigt__p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t = {"_p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t", "iDynTree::Span< double,-1 >::iterator *|iDynTree::details::span_iterator< iDynTree::Span< double,-1 >,false > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t = {"_p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t", "iDynTree::Span< double,-1 >::const_iterator *|iDynTree::details::span_iterator< iDynTree::Span< double,-1 >,true > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iDynTree__estimateExternalWrenchesBuffers = {"_p_iDynTree__estimateExternalWrenchesBuffers", "iDynTree::estimateExternalWrenchesBuffers *", 0, 0, (void*)"iDynTree.estimateExternalWrenchesBuffers", 0};
static swig_type_info _swigt__p_index_type = {"_p_index_type", "index_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_iterator = {"_p_iterator", "iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_pointer = {"_p_pointer", "pointer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_reference = {"_p_reference", "reference *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_reverse_iterator = {"_p_reverse_iterator", "reverse_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_iDynTree__BerdyDynamicVariable_t = {"_p_std__allocatorT_iDynTree__BerdyDynamicVariable_t", "std::vector< iDynTree::BerdyDynamicVariable >::allocator_type *|std::allocator< iDynTree::BerdyDynamicVariable > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_iDynTree__BerdySensor_t = {"_p_std__allocatorT_iDynTree__BerdySensor_t", "std::allocator< iDynTree::BerdySensor > *|std::vector< iDynTree::BerdySensor >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t = {"_p_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t", "std::vector< iDynTree::MatrixFixSize< 4,4 > >::allocator_type *|std::allocator< iDynTree::MatrixFixSize< 4,4 > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_iDynTree__SolidShape_p_t = {"_p_std__allocatorT_iDynTree__SolidShape_p_t", "std::allocator< iDynTree::SolidShape * > *|std::vector< iDynTree::SolidShape * >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_int_t = {"_p_std__allocatorT_int_t", "std::vector< int >::allocator_type *|std::allocator< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__allocatorT_std__string_t", "std::vector< std::string >::allocator_type *|std::allocator< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t = {"_p_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t", "std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > *|std::vector< std::vector< iDynTree::SolidShape * > >::allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ptrdiff_t = {"_p_std__ptrdiff_t", "std::ptrdiff_t *|iDynTree::LinkIndex *|iDynTree::FrameIndex *|iDynTree::TraversalIndex *|iDynTree::JointIndex *|iDynTree::DOFIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t_t = {"_p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t_t", "iDynTree::Span< double,-1 >::reverse_iterator *|std::reverse_iterator< iDynTree::details::span_iterator< iDynTree::Span< double,-1 >,false > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t_t = {"_p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t_t", "std::reverse_iterator< iDynTree::details::span_iterator< iDynTree::Span< double,-1 >,true > > *|iDynTree::Span< double,-1 >::const_reverse_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__size_t = {"_p_std__size_t", "std::size_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t = {"_p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t", "std::vector< iDynTree::BerdyDynamicVariable,std::allocator< iDynTree::BerdyDynamicVariable > > *|std::vector< iDynTree::BerdyDynamicVariable > *", 0, 0, (void*)"iDynTree.BerdyDynamicVariables", 0};
static swig_type_info _swigt__p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t = {"_p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t", "std::vector< iDynTree::BerdySensor > *|std::vector< iDynTree::BerdySensor,std::allocator< iDynTree::BerdySensor > > *", 0, 0, (void*)"iDynTree.BerdySensors", 0};
static swig_type_info _swigt__p_std__vectorT_iDynTree__MatrixDynSize_std__allocatorT_iDynTree__MatrixDynSize_t_t = {"_p_std__vectorT_iDynTree__MatrixDynSize_std__allocatorT_iDynTree__MatrixDynSize_t_t", "std::vector< iDynTree::MatrixDynSize,std::allocator< iDynTree::MatrixDynSize > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t = {"_p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t", "std::vector< iDynTree::MatrixFixSize< 4,4 > > *|std::vector< iDynTree::Matrix4x4 > *|std::vector< iDynTree::MatrixFixSize< 4,4 >,std::allocator< iDynTree::MatrixFixSize< 4,4 > > > *|std::vector< iDynTree::Matrix4x4,std::allocator< iDynTree::Matrix4x4 > > *", 0, 0, (void*)"iDynTree.Matrix4x4Vector", 0};
static swig_type_info _swigt__p_std__vectorT_iDynTree__PixelViz_std__allocatorT_iDynTree__PixelViz_t_t = {"_p_std__vectorT_iDynTree__PixelViz_std__allocatorT_iDynTree__PixelViz_t_t", "std::vector< iDynTree::PixelViz,std::allocator< iDynTree::PixelViz > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_iDynTree__Polygon_std__allocatorT_iDynTree__Polygon_t_t = {"_p_std__vectorT_iDynTree__Polygon_std__allocatorT_iDynTree__Polygon_t_t", "std::vector< iDynTree::Polygon,std::allocator< iDynTree::Polygon > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_iDynTree__Position_std__allocatorT_iDynTree__Position_t_t = {"_p_std__vectorT_iDynTree__Position_std__allocatorT_iDynTree__Position_t_t", "std::vector< iDynTree::Position,std::allocator< iDynTree::Position > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t = {"_p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t", "std::vector< iDynTree::SolidShape * > *|std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > *", 0, 0, (void*)"iDynTree.SolidShapesVector", 0};
static swig_type_info _swigt__p_std__vectorT_iDynTree__Transform_std__allocatorT_iDynTree__Transform_t_t = {"_p_std__vectorT_iDynTree__Transform_std__allocatorT_iDynTree__Transform_t_t", "std::vector< iDynTree::Transform,std::allocator< iDynTree::Transform > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_iDynTree__VectorDynSize_std__allocatorT_iDynTree__VectorDynSize_t_t = {"_p_std__vectorT_iDynTree__VectorDynSize_std__allocatorT_iDynTree__VectorDynSize_t_t", "std::vector< iDynTree::VectorDynSize,std::allocator< iDynTree::VectorDynSize > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_iDynTree__VectorFixSizeT_2_t_std__allocatorT_iDynTree__VectorFixSizeT_2_t_t_t = {"_p_std__vectorT_iDynTree__VectorFixSizeT_2_t_std__allocatorT_iDynTree__VectorFixSizeT_2_t_t_t", "std::vector< iDynTree::Vector2,std::allocator< iDynTree::Vector2 > > *|std::vector< iDynTree::VectorFixSize< 2 >,std::allocator< iDynTree::VectorFixSize< 2 > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_iDynTree__VectorFixSizeT_6_t_std__allocatorT_iDynTree__VectorFixSizeT_6_t_t_t = {"_p_std__vectorT_iDynTree__VectorFixSizeT_6_t_std__allocatorT_iDynTree__VectorFixSizeT_6_t_t_t", "std::vector< iDynTree::Vector6,std::allocator< iDynTree::Vector6 > > *|std::vector< iDynTree::VectorFixSize< 6 >,std::allocator< iDynTree::VectorFixSize< 6 > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_int_std__allocatorT_int_t_t = {"_p_std__vectorT_int_std__allocatorT_int_t_t", "std::vector< int,std::allocator< int > > *|std::vector< int > *", 0, 0, (void*)"iDynTree.IntVector", 0};
static swig_type_info _swigt__p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t = {"_p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t", "std::vector< std::pair< double,double >,std::allocator< std::pair< double,double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__ptrdiff_t_std__allocatorT_std__ptrdiff_t_t_t = {"_p_std__vectorT_std__ptrdiff_t_std__allocatorT_std__ptrdiff_t_t_t", "std::vector< std::ptrdiff_t,std::allocator< std::ptrdiff_t > > *|std::vector< iDynTree::FrameIndex,std::allocator< iDynTree::FrameIndex > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "std::vector< std::string,std::allocator< std::string > > *|std::vector< std::string > *", 0, 0, (void*)"iDynTree.StringVector", 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t = {"_p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t", "std::vector< std::vector< iDynTree::SolidShape * > > *|std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > >,std::allocator< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > > *|std::vector< std::vector< iDynTree::SolidShape *,std::allocator< iDynTree::SolidShape * > > > *", 0, 0, (void*)"iDynTree.LinksSolidShapesVector", 0};
static swig_type_info _swigt__p_swig__MatlabSwigIterator = {"_p_swig__MatlabSwigIterator", "swig::MatlabSwigIterator *", 0, 0, (void*)"iDynTree.MatlabSwigIterator", 0};
static swig_type_info _swigt__p_typed_iterator = {"_p_typed_iterator", "typed_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_AngularVector3T,
  &_swigt__p_DualVectorT,
  &_swigt__p_LinearVector3T,
  &_swigt__p_Type,
  &_swigt__p_allocator_type,
  &_swigt__p_char,
  &_swigt__p_const_iterator,
  &_swigt__p_const_pointer,
  &_swigt__p_const_reference,
  &_swigt__p_const_reverse_iterator,
  &_swigt__p_const_typed_iterator,
  &_swigt__p_difference_type,
  &_swigt__p_double,
  &_swigt__p_element_type,
  &_swigt__p_iDynTree__AccelerometerSensor,
  &_swigt__p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers,
  &_swigt__p_iDynTree__ArticulatedBodyInertia,
  &_swigt__p_iDynTree__AttitudeEstimatorState,
  &_swigt__p_iDynTree__AttitudeMahonyFilter,
  &_swigt__p_iDynTree__AttitudeMahonyFilterParameters,
  &_swigt__p_iDynTree__AttitudeQuaternionEKF,
  &_swigt__p_iDynTree__AttitudeQuaternionEKFParameters,
  &_swigt__p_iDynTree__Axis,
  &_swigt__p_iDynTree__BerdyDynamicVariable,
  &_swigt__p_iDynTree__BerdyHelper,
  &_swigt__p_iDynTree__BerdyOptions,
  &_swigt__p_iDynTree__BerdySensor,
  &_swigt__p_iDynTree__BerdySparseMAPSolver,
  &_swigt__p_iDynTree__Box,
  &_swigt__p_iDynTree__ClassicalAcc,
  &_swigt__p_iDynTree__ColorViz,
  &_swigt__p_iDynTree__ContactWrench,
  &_swigt__p_iDynTree__ConvexHullProjectionConstraint,
  &_swigt__p_iDynTree__Cylinder,
  &_swigt__p_iDynTree__DOFSpatialForceArray,
  &_swigt__p_iDynTree__DOFSpatialMotionArray,
  &_swigt__p_iDynTree__Direction,
  &_swigt__p_iDynTree__DiscreteExtendedKalmanFilterHelper,
  &_swigt__p_iDynTree__Dummy,
  &_swigt__p_iDynTree__ExtWrenchesAndJointTorquesEstimator,
  &_swigt__p_iDynTree__ExternalMesh,
  &_swigt__p_iDynTree__FixedJoint,
  &_swigt__p_iDynTree__FrameFreeFloatingJacobian,
  &_swigt__p_iDynTree__FreeFloatingAcc,
  &_swigt__p_iDynTree__FreeFloatingGeneralizedTorques,
  &_swigt__p_iDynTree__FreeFloatingMassMatrix,
  &_swigt__p_iDynTree__FreeFloatingPos,
  &_swigt__p_iDynTree__FreeFloatingVel,
  &_swigt__p_iDynTree__GeomVector3,
  &_swigt__p_iDynTree__GyroscopeSensor,
  &_swigt__p_iDynTree__IAttitudeEstimator,
  &_swigt__p_iDynTree__ICamera,
  &_swigt__p_iDynTree__ICameraAnimator,
  &_swigt__p_iDynTree__IEnvironment,
  &_swigt__p_iDynTree__IFrameVisualization,
  &_swigt__p_iDynTree__IJetsVisualization,
  &_swigt__p_iDynTree__IJoint,
  &_swigt__p_iDynTree__ILight,
  &_swigt__p_iDynTree__IModelVisualization,
  &_swigt__p_iDynTree__ITexture,
  &_swigt__p_iDynTree__ITexturesHandler,
  &_swigt__p_iDynTree__IVectorsVisualization,
  &_swigt__p_iDynTree__IndexRange,
  &_swigt__p_iDynTree__InverseKinematics,
  &_swigt__p_iDynTree__JointDOFsDoubleArray,
  &_swigt__p_iDynTree__JointPosDoubleArray,
  &_swigt__p_iDynTree__JointSensor,
  &_swigt__p_iDynTree__KinDynComputations,
  &_swigt__p_iDynTree__Link,
  &_swigt__p_iDynTree__LinkAccArray,
  &_swigt__p_iDynTree__LinkArticulatedBodyInertias,
  &_swigt__p_iDynTree__LinkContactWrenches,
  &_swigt__p_iDynTree__LinkInertias,
  &_swigt__p_iDynTree__LinkPositions,
  &_swigt__p_iDynTree__LinkSensor,
  &_swigt__p_iDynTree__LinkUnknownWrenchContacts,
  &_swigt__p_iDynTree__LinkVelArray,
  &_swigt__p_iDynTree__LinkWrenches,
  &_swigt__p_iDynTree__Material,
  &_swigt__p_iDynTree__MatrixDynSize,
  &_swigt__p_iDynTree__MatrixFixSizeT_10_16_t,
  &_swigt__p_iDynTree__MatrixFixSizeT_1_6_t,
  &_swigt__p_iDynTree__MatrixFixSizeT_2_3_t,
  &_swigt__p_iDynTree__MatrixFixSizeT_3_3_t,
  &_swigt__p_iDynTree__MatrixFixSizeT_3_4_t,
  &_swigt__p_iDynTree__MatrixFixSizeT_4_3_t,
  &_swigt__p_iDynTree__MatrixFixSizeT_4_4_t,
  &_swigt__p_iDynTree__MatrixFixSizeT_6_10_t,
  &_swigt__p_iDynTree__MatrixFixSizeT_6_1_t,
  &_swigt__p_iDynTree__MatrixFixSizeT_6_6_t,
  &_swigt__p_iDynTree__MatrixViewT_double_const_t,
  &_swigt__p_iDynTree__MatrixViewT_double_t,
  &_swigt__p_iDynTree__Model,
  &_swigt__p_iDynTree__ModelCalibrationHelper,
  &_swigt__p_iDynTree__ModelExporter,
  &_swigt__p_iDynTree__ModelExporterOptions,
  &_swigt__p_iDynTree__ModelLoader,
  &_swigt__p_iDynTree__ModelParserOptions,
  &_swigt__p_iDynTree__ModelSolidShapes,
  &_swigt__p_iDynTree__MomentumFreeFloatingJacobian,
  &_swigt__p_iDynTree__MovableJointImplT_1_1_t,
  &_swigt__p_iDynTree__MovableJointImplT_2_2_t,
  &_swigt__p_iDynTree__MovableJointImplT_3_3_t,
  &_swigt__p_iDynTree__MovableJointImplT_4_4_t,
  &_swigt__p_iDynTree__MovableJointImplT_5_5_t,
  &_swigt__p_iDynTree__MovableJointImplT_6_6_t,
  &_swigt__p_iDynTree__Neighbor,
  &_swigt__p_iDynTree__PixelViz,
  &_swigt__p_iDynTree__Polygon,
  &_swigt__p_iDynTree__Polygon2D,
  &_swigt__p_iDynTree__Position,
  &_swigt__p_iDynTree__PositionRaw,
  &_swigt__p_iDynTree__PrismaticJoint,
  &_swigt__p_iDynTree__RevoluteJoint,
  &_swigt__p_iDynTree__RigidBodyInertiaNonLinearParametrization,
  &_swigt__p_iDynTree__Rotation,
  &_swigt__p_iDynTree__RotationRaw,
  &_swigt__p_iDynTree__RotationalInertiaRaw,
  &_swigt__p_iDynTree__Sensor,
  &_swigt__p_iDynTree__SensorsList,
  &_swigt__p_iDynTree__SensorsMeasurements,
  &_swigt__p_iDynTree__SimpleLeggedOdometry,
  &_swigt__p_iDynTree__SixAxisForceTorqueSensor,
  &_swigt__p_iDynTree__SolidShape,
  &_swigt__p_iDynTree__SpanT_double__1_t,
  &_swigt__p_iDynTree__SpanT_double_const__1_t,
  &_swigt__p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t,
  &_swigt__p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t,
  &_swigt__p_iDynTree__SpatialAcc,
  &_swigt__p_iDynTree__SpatialForceVector,
  &_swigt__p_iDynTree__SpatialInertia,
  &_swigt__p_iDynTree__SpatialInertiaRaw,
  &_swigt__p_iDynTree__SpatialMomentum,
  &_swigt__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type,
  &_swigt__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type,
  &_swigt__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__AngularVector3Type,
  &_swigt__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__LinearVector3Type,
  &_swigt__p_iDynTree__SpatialMotionVector,
  &_swigt__p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t,
  &_swigt__p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t,
  &_swigt__p_iDynTree__Sphere,
  &_swigt__p_iDynTree__SubModelDecomposition,
  &_swigt__p_iDynTree__ThreeAxisAngularAccelerometerSensor,
  &_swigt__p_iDynTree__ThreeAxisForceTorqueContactSensor,
  &_swigt__p_iDynTree__Transform,
  &_swigt__p_iDynTree__TransformDerivative,
  &_swigt__p_iDynTree__Traversal,
  &_swigt__p_iDynTree__Triplets,
  &_swigt__p_iDynTree__Twist,
  &_swigt__p_iDynTree__UnknownWrenchContact,
  &_swigt__p_iDynTree__VectorDynSize,
  &_swigt__p_iDynTree__VectorFixSizeT_10_t,
  &_swigt__p_iDynTree__VectorFixSizeT_16_t,
  &_swigt__p_iDynTree__VectorFixSizeT_2_t,
  &_swigt__p_iDynTree__VectorFixSizeT_3_t,
  &_swigt__p_iDynTree__VectorFixSizeT_4_t,
  &_swigt__p_iDynTree__VectorFixSizeT_6_t,
  &_swigt__p_iDynTree__Visualizer,
  &_swigt__p_iDynTree__VisualizerOptions,
  &_swigt__p_iDynTree__Wrench,
  &_swigt__p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t,
  &_swigt__p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t,
  &_swigt__p_iDynTree__estimateExternalWrenchesBuffers,
  &_swigt__p_index_type,
  &_swigt__p_iterator,
  &_swigt__p_pointer,
  &_swigt__p_reference,
  &_swigt__p_reverse_iterator,
  &_swigt__p_size_type,
  &_swigt__p_std__allocatorT_iDynTree__BerdyDynamicVariable_t,
  &_swigt__p_std__allocatorT_iDynTree__BerdySensor_t,
  &_swigt__p_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t,
  &_swigt__p_std__allocatorT_iDynTree__SolidShape_p_t,
  &_swigt__p_std__allocatorT_int_t,
  &_swigt__p_std__allocatorT_std__string_t,
  &_swigt__p_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t,
  &_swigt__p_std__ptrdiff_t,
  &_swigt__p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t_t,
  &_swigt__p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t_t,
  &_swigt__p_std__size_t,
  &_swigt__p_std__string,
  &_swigt__p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t,
  &_swigt__p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t,
  &_swigt__p_std__vectorT_iDynTree__MatrixDynSize_std__allocatorT_iDynTree__MatrixDynSize_t_t,
  &_swigt__p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t,
  &_swigt__p_std__vectorT_iDynTree__PixelViz_std__allocatorT_iDynTree__PixelViz_t_t,
  &_swigt__p_std__vectorT_iDynTree__Polygon_std__allocatorT_iDynTree__Polygon_t_t,
  &_swigt__p_std__vectorT_iDynTree__Position_std__allocatorT_iDynTree__Position_t_t,
  &_swigt__p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t,
  &_swigt__p_std__vectorT_iDynTree__Transform_std__allocatorT_iDynTree__Transform_t_t,
  &_swigt__p_std__vectorT_iDynTree__VectorDynSize_std__allocatorT_iDynTree__VectorDynSize_t_t,
  &_swigt__p_std__vectorT_iDynTree__VectorFixSizeT_2_t_std__allocatorT_iDynTree__VectorFixSizeT_2_t_t_t,
  &_swigt__p_std__vectorT_iDynTree__VectorFixSizeT_6_t_std__allocatorT_iDynTree__VectorFixSizeT_6_t_t_t,
  &_swigt__p_std__vectorT_int_std__allocatorT_int_t_t,
  &_swigt__p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t,
  &_swigt__p_std__vectorT_std__ptrdiff_t_std__allocatorT_std__ptrdiff_t_t_t,
  &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
  &_swigt__p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t,
  &_swigt__p_swig__MatlabSwigIterator,
  &_swigt__p_typed_iterator,
  &_swigt__p_unsigned_int,
  &_swigt__p_value_type,
};

static swig_cast_info _swigc__p_AngularVector3T[] = {  {&_swigt__p_AngularVector3T, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_DualVectorT[] = {  {&_swigt__p_DualVectorT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_LinearVector3T[] = {  {&_swigt__p_LinearVector3T, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Type[] = {  {&_swigt__p_Type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_iterator[] = {  {&_swigt__p_const_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_pointer[] = {  {&_swigt__p_const_pointer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_reference[] = {  {&_swigt__p_const_reference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_reverse_iterator[] = {  {&_swigt__p_const_reverse_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_const_typed_iterator[] = {  {&_swigt__p_const_typed_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_element_type[] = {  {&_swigt__p_element_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__AccelerometerSensor[] = {  {&_swigt__p_iDynTree__AccelerometerSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers[] = {  {&_swigt__p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ArticulatedBodyInertia[] = {  {&_swigt__p_iDynTree__ArticulatedBodyInertia, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__AttitudeEstimatorState[] = {  {&_swigt__p_iDynTree__AttitudeEstimatorState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__AttitudeMahonyFilter[] = {  {&_swigt__p_iDynTree__AttitudeMahonyFilter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__AttitudeMahonyFilterParameters[] = {  {&_swigt__p_iDynTree__AttitudeMahonyFilterParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__AttitudeQuaternionEKF[] = {  {&_swigt__p_iDynTree__AttitudeQuaternionEKF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__AttitudeQuaternionEKFParameters[] = {  {&_swigt__p_iDynTree__AttitudeQuaternionEKFParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Axis[] = {  {&_swigt__p_iDynTree__Axis, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__BerdyDynamicVariable[] = {  {&_swigt__p_iDynTree__BerdyDynamicVariable, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__BerdyHelper[] = {  {&_swigt__p_iDynTree__BerdyHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__BerdyOptions[] = {  {&_swigt__p_iDynTree__BerdyOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__BerdySensor[] = {  {&_swigt__p_iDynTree__BerdySensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__BerdySparseMAPSolver[] = {  {&_swigt__p_iDynTree__BerdySparseMAPSolver, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Box[] = {  {&_swigt__p_iDynTree__Box, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ClassicalAcc[] = {  {&_swigt__p_iDynTree__ClassicalAcc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ColorViz[] = {  {&_swigt__p_iDynTree__PixelViz, _p_iDynTree__PixelVizTo_p_iDynTree__ColorViz, 0, 0},  {&_swigt__p_iDynTree__ColorViz, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ContactWrench[] = {  {&_swigt__p_iDynTree__ContactWrench, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ConvexHullProjectionConstraint[] = {  {&_swigt__p_iDynTree__ConvexHullProjectionConstraint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Cylinder[] = {  {&_swigt__p_iDynTree__Cylinder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__DOFSpatialForceArray[] = {  {&_swigt__p_iDynTree__DOFSpatialForceArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__DOFSpatialMotionArray[] = {  {&_swigt__p_iDynTree__DOFSpatialMotionArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Direction[] = {  {&_swigt__p_iDynTree__Direction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__DiscreteExtendedKalmanFilterHelper[] = {  {&_swigt__p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0, 0, 0},  {&_swigt__p_iDynTree__AttitudeQuaternionEKF, _p_iDynTree__AttitudeQuaternionEKFTo_p_iDynTree__DiscreteExtendedKalmanFilterHelper, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Dummy[] = {  {&_swigt__p_iDynTree__Dummy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ExtWrenchesAndJointTorquesEstimator[] = {  {&_swigt__p_iDynTree__ExtWrenchesAndJointTorquesEstimator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ExternalMesh[] = {  {&_swigt__p_iDynTree__ExternalMesh, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__FixedJoint[] = {  {&_swigt__p_iDynTree__FixedJoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__FrameFreeFloatingJacobian[] = {  {&_swigt__p_iDynTree__FrameFreeFloatingJacobian, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__FreeFloatingAcc[] = {  {&_swigt__p_iDynTree__FreeFloatingAcc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__FreeFloatingGeneralizedTorques[] = {  {&_swigt__p_iDynTree__FreeFloatingGeneralizedTorques, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__FreeFloatingMassMatrix[] = {  {&_swigt__p_iDynTree__FreeFloatingMassMatrix, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__FreeFloatingPos[] = {  {&_swigt__p_iDynTree__FreeFloatingPos, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__FreeFloatingVel[] = {  {&_swigt__p_iDynTree__FreeFloatingVel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__GeomVector3[] = {  {&_swigt__p_iDynTree__GeomVector3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__GyroscopeSensor[] = {  {&_swigt__p_iDynTree__GyroscopeSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__IAttitudeEstimator[] = {  {&_swigt__p_iDynTree__AttitudeMahonyFilter, _p_iDynTree__AttitudeMahonyFilterTo_p_iDynTree__IAttitudeEstimator, 0, 0},  {&_swigt__p_iDynTree__AttitudeQuaternionEKF, _p_iDynTree__AttitudeQuaternionEKFTo_p_iDynTree__IAttitudeEstimator, 0, 0},  {&_swigt__p_iDynTree__IAttitudeEstimator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ICamera[] = {  {&_swigt__p_iDynTree__ICamera, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ICameraAnimator[] = {  {&_swigt__p_iDynTree__ICameraAnimator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__IEnvironment[] = {  {&_swigt__p_iDynTree__IEnvironment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__IFrameVisualization[] = {  {&_swigt__p_iDynTree__IFrameVisualization, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__IJetsVisualization[] = {  {&_swigt__p_iDynTree__IJetsVisualization, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__IJoint[] = {  {&_swigt__p_iDynTree__MovableJointImplT_3_3_t, _p_iDynTree__MovableJointImplT_3_3_tTo_p_iDynTree__IJoint, 0, 0},  {&_swigt__p_iDynTree__RevoluteJoint, _p_iDynTree__RevoluteJointTo_p_iDynTree__IJoint, 0, 0},  {&_swigt__p_iDynTree__MovableJointImplT_2_2_t, _p_iDynTree__MovableJointImplT_2_2_tTo_p_iDynTree__IJoint, 0, 0},  {&_swigt__p_iDynTree__IJoint, 0, 0, 0},  {&_swigt__p_iDynTree__MovableJointImplT_1_1_t, _p_iDynTree__MovableJointImplT_1_1_tTo_p_iDynTree__IJoint, 0, 0},  {&_swigt__p_iDynTree__PrismaticJoint, _p_iDynTree__PrismaticJointTo_p_iDynTree__IJoint, 0, 0},  {&_swigt__p_iDynTree__MovableJointImplT_6_6_t, _p_iDynTree__MovableJointImplT_6_6_tTo_p_iDynTree__IJoint, 0, 0},  {&_swigt__p_iDynTree__MovableJointImplT_5_5_t, _p_iDynTree__MovableJointImplT_5_5_tTo_p_iDynTree__IJoint, 0, 0},  {&_swigt__p_iDynTree__FixedJoint, _p_iDynTree__FixedJointTo_p_iDynTree__IJoint, 0, 0},  {&_swigt__p_iDynTree__MovableJointImplT_4_4_t, _p_iDynTree__MovableJointImplT_4_4_tTo_p_iDynTree__IJoint, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ILight[] = {  {&_swigt__p_iDynTree__ILight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__IModelVisualization[] = {  {&_swigt__p_iDynTree__IModelVisualization, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ITexture[] = {  {&_swigt__p_iDynTree__ITexture, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ITexturesHandler[] = {  {&_swigt__p_iDynTree__ITexturesHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__IVectorsVisualization[] = {  {&_swigt__p_iDynTree__IVectorsVisualization, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__IndexRange[] = {  {&_swigt__p_iDynTree__IndexRange, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__InverseKinematics[] = {  {&_swigt__p_iDynTree__InverseKinematics, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__JointDOFsDoubleArray[] = {  {&_swigt__p_iDynTree__JointDOFsDoubleArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__JointPosDoubleArray[] = {  {&_swigt__p_iDynTree__JointPosDoubleArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__JointSensor[] = {  {&_swigt__p_iDynTree__JointSensor, 0, 0, 0},  {&_swigt__p_iDynTree__SixAxisForceTorqueSensor, _p_iDynTree__SixAxisForceTorqueSensorTo_p_iDynTree__JointSensor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__KinDynComputations[] = {  {&_swigt__p_iDynTree__KinDynComputations, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Link[] = {  {&_swigt__p_iDynTree__Link, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__LinkAccArray[] = {  {&_swigt__p_iDynTree__LinkAccArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__LinkArticulatedBodyInertias[] = {  {&_swigt__p_iDynTree__LinkArticulatedBodyInertias, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__LinkContactWrenches[] = {  {&_swigt__p_iDynTree__LinkContactWrenches, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__LinkInertias[] = {  {&_swigt__p_iDynTree__LinkInertias, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__LinkPositions[] = {  {&_swigt__p_iDynTree__LinkPositions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__LinkSensor[] = {  {&_swigt__p_iDynTree__AccelerometerSensor, _p_iDynTree__AccelerometerSensorTo_p_iDynTree__LinkSensor, 0, 0},  {&_swigt__p_iDynTree__ThreeAxisAngularAccelerometerSensor, _p_iDynTree__ThreeAxisAngularAccelerometerSensorTo_p_iDynTree__LinkSensor, 0, 0},  {&_swigt__p_iDynTree__ThreeAxisForceTorqueContactSensor, _p_iDynTree__ThreeAxisForceTorqueContactSensorTo_p_iDynTree__LinkSensor, 0, 0},  {&_swigt__p_iDynTree__LinkSensor, 0, 0, 0},  {&_swigt__p_iDynTree__GyroscopeSensor, _p_iDynTree__GyroscopeSensorTo_p_iDynTree__LinkSensor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__LinkUnknownWrenchContacts[] = {  {&_swigt__p_iDynTree__LinkUnknownWrenchContacts, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__LinkVelArray[] = {  {&_swigt__p_iDynTree__LinkVelArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__LinkWrenches[] = {  {&_swigt__p_iDynTree__LinkWrenches, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Material[] = {  {&_swigt__p_iDynTree__Material, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MatrixDynSize[] = {  {&_swigt__p_iDynTree__MatrixDynSize, 0, 0, 0},  {&_swigt__p_iDynTree__FrameFreeFloatingJacobian, _p_iDynTree__FrameFreeFloatingJacobianTo_p_iDynTree__MatrixDynSize, 0, 0},  {&_swigt__p_iDynTree__MomentumFreeFloatingJacobian, _p_iDynTree__MomentumFreeFloatingJacobianTo_p_iDynTree__MatrixDynSize, 0, 0},  {&_swigt__p_iDynTree__FreeFloatingMassMatrix, _p_iDynTree__FreeFloatingMassMatrixTo_p_iDynTree__MatrixDynSize, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MatrixFixSizeT_10_16_t[] = {  {&_swigt__p_iDynTree__MatrixFixSizeT_10_16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MatrixFixSizeT_1_6_t[] = {  {&_swigt__p_iDynTree__MatrixFixSizeT_1_6_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MatrixFixSizeT_2_3_t[] = {  {&_swigt__p_iDynTree__MatrixFixSizeT_2_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MatrixFixSizeT_3_3_t[] = {  {&_swigt__p_iDynTree__MatrixFixSizeT_3_3_t, 0, 0, 0},  {&_swigt__p_iDynTree__RotationalInertiaRaw, _p_iDynTree__RotationalInertiaRawTo_p_iDynTree__MatrixFixSizeT_3_3_t, 0, 0},  {&_swigt__p_iDynTree__RotationRaw, _p_iDynTree__RotationRawTo_p_iDynTree__MatrixFixSizeT_3_3_t, 0, 0},  {&_swigt__p_iDynTree__Rotation, _p_iDynTree__RotationTo_p_iDynTree__MatrixFixSizeT_3_3_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MatrixFixSizeT_3_4_t[] = {  {&_swigt__p_iDynTree__MatrixFixSizeT_3_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MatrixFixSizeT_4_3_t[] = {  {&_swigt__p_iDynTree__MatrixFixSizeT_4_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MatrixFixSizeT_4_4_t[] = {  {&_swigt__p_iDynTree__MatrixFixSizeT_4_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MatrixFixSizeT_6_10_t[] = {  {&_swigt__p_iDynTree__MatrixFixSizeT_6_10_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MatrixFixSizeT_6_1_t[] = {  {&_swigt__p_iDynTree__MatrixFixSizeT_6_1_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MatrixFixSizeT_6_6_t[] = {  {&_swigt__p_iDynTree__MatrixFixSizeT_6_6_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MatrixViewT_double_const_t[] = {  {&_swigt__p_iDynTree__MatrixViewT_double_const_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MatrixViewT_double_t[] = {  {&_swigt__p_iDynTree__MatrixViewT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Model[] = {  {&_swigt__p_iDynTree__Model, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ModelCalibrationHelper[] = {  {&_swigt__p_iDynTree__ModelCalibrationHelper, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ModelExporter[] = {  {&_swigt__p_iDynTree__ModelExporter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ModelExporterOptions[] = {  {&_swigt__p_iDynTree__ModelExporterOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ModelLoader[] = {  {&_swigt__p_iDynTree__ModelLoader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ModelParserOptions[] = {  {&_swigt__p_iDynTree__ModelParserOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ModelSolidShapes[] = {  {&_swigt__p_iDynTree__ModelSolidShapes, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MomentumFreeFloatingJacobian[] = {  {&_swigt__p_iDynTree__MomentumFreeFloatingJacobian, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MovableJointImplT_1_1_t[] = {  {&_swigt__p_iDynTree__RevoluteJoint, _p_iDynTree__RevoluteJointTo_p_iDynTree__MovableJointImplT_1_1_t, 0, 0},  {&_swigt__p_iDynTree__MovableJointImplT_1_1_t, 0, 0, 0},  {&_swigt__p_iDynTree__PrismaticJoint, _p_iDynTree__PrismaticJointTo_p_iDynTree__MovableJointImplT_1_1_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MovableJointImplT_2_2_t[] = {  {&_swigt__p_iDynTree__MovableJointImplT_2_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MovableJointImplT_3_3_t[] = {  {&_swigt__p_iDynTree__MovableJointImplT_3_3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MovableJointImplT_4_4_t[] = {  {&_swigt__p_iDynTree__MovableJointImplT_4_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MovableJointImplT_5_5_t[] = {  {&_swigt__p_iDynTree__MovableJointImplT_5_5_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__MovableJointImplT_6_6_t[] = {  {&_swigt__p_iDynTree__MovableJointImplT_6_6_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Neighbor[] = {  {&_swigt__p_iDynTree__Neighbor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__PixelViz[] = {  {&_swigt__p_iDynTree__PixelViz, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Polygon[] = {  {&_swigt__p_iDynTree__Polygon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Polygon2D[] = {  {&_swigt__p_iDynTree__Polygon2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Position[] = {  {&_swigt__p_iDynTree__Position, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__PositionRaw[] = {  {&_swigt__p_iDynTree__Position, _p_iDynTree__PositionTo_p_iDynTree__PositionRaw, 0, 0},  {&_swigt__p_iDynTree__PositionRaw, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__PrismaticJoint[] = {  {&_swigt__p_iDynTree__PrismaticJoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__RevoluteJoint[] = {  {&_swigt__p_iDynTree__RevoluteJoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__RigidBodyInertiaNonLinearParametrization[] = {  {&_swigt__p_iDynTree__RigidBodyInertiaNonLinearParametrization, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Rotation[] = {  {&_swigt__p_iDynTree__Rotation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__RotationRaw[] = {  {&_swigt__p_iDynTree__RotationRaw, 0, 0, 0},  {&_swigt__p_iDynTree__Rotation, _p_iDynTree__RotationTo_p_iDynTree__RotationRaw, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__RotationalInertiaRaw[] = {  {&_swigt__p_iDynTree__RotationalInertiaRaw, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Sensor[] = {  {&_swigt__p_iDynTree__JointSensor, _p_iDynTree__JointSensorTo_p_iDynTree__Sensor, 0, 0},  {&_swigt__p_iDynTree__AccelerometerSensor, _p_iDynTree__AccelerometerSensorTo_p_iDynTree__Sensor, 0, 0},  {&_swigt__p_iDynTree__ThreeAxisAngularAccelerometerSensor, _p_iDynTree__ThreeAxisAngularAccelerometerSensorTo_p_iDynTree__Sensor, 0, 0},  {&_swigt__p_iDynTree__ThreeAxisForceTorqueContactSensor, _p_iDynTree__ThreeAxisForceTorqueContactSensorTo_p_iDynTree__Sensor, 0, 0},  {&_swigt__p_iDynTree__Sensor, 0, 0, 0},  {&_swigt__p_iDynTree__SixAxisForceTorqueSensor, _p_iDynTree__SixAxisForceTorqueSensorTo_p_iDynTree__Sensor, 0, 0},  {&_swigt__p_iDynTree__LinkSensor, _p_iDynTree__LinkSensorTo_p_iDynTree__Sensor, 0, 0},  {&_swigt__p_iDynTree__GyroscopeSensor, _p_iDynTree__GyroscopeSensorTo_p_iDynTree__Sensor, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SensorsList[] = {  {&_swigt__p_iDynTree__SensorsList, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SensorsMeasurements[] = {  {&_swigt__p_iDynTree__SensorsMeasurements, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SimpleLeggedOdometry[] = {  {&_swigt__p_iDynTree__SimpleLeggedOdometry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SixAxisForceTorqueSensor[] = {  {&_swigt__p_iDynTree__SixAxisForceTorqueSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SolidShape[] = {  {&_swigt__p_iDynTree__SolidShape, 0, 0, 0},  {&_swigt__p_iDynTree__ExternalMesh, _p_iDynTree__ExternalMeshTo_p_iDynTree__SolidShape, 0, 0},  {&_swigt__p_iDynTree__Box, _p_iDynTree__BoxTo_p_iDynTree__SolidShape, 0, 0},  {&_swigt__p_iDynTree__Cylinder, _p_iDynTree__CylinderTo_p_iDynTree__SolidShape, 0, 0},  {&_swigt__p_iDynTree__Sphere, _p_iDynTree__SphereTo_p_iDynTree__SolidShape, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SpanT_double__1_t[] = {  {&_swigt__p_iDynTree__SpanT_double__1_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SpanT_double_const__1_t[] = {  {&_swigt__p_iDynTree__SpanT_double_const__1_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t[] = {  {&_swigt__p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t[] = {  {&_swigt__p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SpatialAcc[] = {  {&_swigt__p_iDynTree__SpatialAcc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SpatialForceVector[] = {  {&_swigt__p_iDynTree__SpatialForceVector, 0, 0, 0},  {&_swigt__p_iDynTree__Wrench, _p_iDynTree__WrenchTo_p_iDynTree__SpatialForceVector, 0, 0},  {&_swigt__p_iDynTree__SpatialMomentum, _p_iDynTree__SpatialMomentumTo_p_iDynTree__SpatialForceVector, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SpatialInertia[] = {  {&_swigt__p_iDynTree__SpatialInertia, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SpatialInertiaRaw[] = {  {&_swigt__p_iDynTree__SpatialInertia, _p_iDynTree__SpatialInertiaTo_p_iDynTree__SpatialInertiaRaw, 0, 0},  {&_swigt__p_iDynTree__SpatialInertiaRaw, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SpatialMomentum[] = {  {&_swigt__p_iDynTree__SpatialMomentum, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type[] = {  {&_swigt__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type[] = {  {&_swigt__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__AngularVector3Type[] = {  {&_swigt__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__AngularVector3Type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__LinearVector3Type[] = {  {&_swigt__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__LinearVector3Type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SpatialMotionVector[] = {  {&_swigt__p_iDynTree__SpatialMotionVector, 0, 0, 0},  {&_swigt__p_iDynTree__Twist, _p_iDynTree__TwistTo_p_iDynTree__SpatialMotionVector, 0, 0},  {&_swigt__p_iDynTree__SpatialAcc, _p_iDynTree__SpatialAccTo_p_iDynTree__SpatialMotionVector, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t[] = {  {&_swigt__p_iDynTree__Wrench, _p_iDynTree__WrenchTo_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0, 0},  {&_swigt__p_iDynTree__SpatialForceVector, _p_iDynTree__SpatialForceVectorTo_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0, 0},  {&_swigt__p_iDynTree__SpatialMomentum, _p_iDynTree__SpatialMomentumTo_p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0, 0},  {&_swigt__p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t[] = {  {&_swigt__p_iDynTree__SpatialMotionVector, _p_iDynTree__SpatialMotionVectorTo_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0, 0},  {&_swigt__p_iDynTree__Twist, _p_iDynTree__TwistTo_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0, 0},  {&_swigt__p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0, 0, 0},  {&_swigt__p_iDynTree__SpatialAcc, _p_iDynTree__SpatialAccTo_p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Sphere[] = {  {&_swigt__p_iDynTree__Sphere, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__SubModelDecomposition[] = {  {&_swigt__p_iDynTree__SubModelDecomposition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ThreeAxisAngularAccelerometerSensor[] = {  {&_swigt__p_iDynTree__ThreeAxisAngularAccelerometerSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__ThreeAxisForceTorqueContactSensor[] = {  {&_swigt__p_iDynTree__ThreeAxisForceTorqueContactSensor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Transform[] = {  {&_swigt__p_iDynTree__Transform, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__TransformDerivative[] = {  {&_swigt__p_iDynTree__TransformDerivative, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Traversal[] = {  {&_swigt__p_iDynTree__Traversal, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Triplets[] = {  {&_swigt__p_iDynTree__Triplets, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Twist[] = {  {&_swigt__p_iDynTree__Twist, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__UnknownWrenchContact[] = {  {&_swigt__p_iDynTree__UnknownWrenchContact, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__VectorDynSize[] = {  {&_swigt__p_iDynTree__VectorDynSize, 0, 0, 0},  {&_swigt__p_iDynTree__JointPosDoubleArray, _p_iDynTree__JointPosDoubleArrayTo_p_iDynTree__VectorDynSize, 0, 0},  {&_swigt__p_iDynTree__JointDOFsDoubleArray, _p_iDynTree__JointDOFsDoubleArrayTo_p_iDynTree__VectorDynSize, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__VectorFixSizeT_10_t[] = {  {&_swigt__p_iDynTree__VectorFixSizeT_10_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__VectorFixSizeT_16_t[] = {  {&_swigt__p_iDynTree__VectorFixSizeT_16_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__VectorFixSizeT_2_t[] = {  {&_swigt__p_iDynTree__VectorFixSizeT_2_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__VectorFixSizeT_3_t[] = {  {&_swigt__p_iDynTree__Position, _p_iDynTree__PositionTo_p_iDynTree__VectorFixSizeT_3_t, 0, 0},  {&_swigt__p_iDynTree__VectorFixSizeT_3_t, 0, 0, 0},  {&_swigt__p_iDynTree__PositionRaw, _p_iDynTree__PositionRawTo_p_iDynTree__VectorFixSizeT_3_t, 0, 0},  {&_swigt__p_iDynTree__GeomVector3, _p_iDynTree__GeomVector3To_p_iDynTree__VectorFixSizeT_3_t, 0, 0},  {&_swigt__p_iDynTree__Direction, _p_iDynTree__DirectionTo_p_iDynTree__VectorFixSizeT_3_t, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__VectorFixSizeT_4_t[] = {  {&_swigt__p_iDynTree__VectorFixSizeT_4_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__VectorFixSizeT_6_t[] = {  {&_swigt__p_iDynTree__ClassicalAcc, _p_iDynTree__ClassicalAccTo_p_iDynTree__VectorFixSizeT_6_t, 0, 0},  {&_swigt__p_iDynTree__VectorFixSizeT_6_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Visualizer[] = {  {&_swigt__p_iDynTree__Visualizer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__VisualizerOptions[] = {  {&_swigt__p_iDynTree__VisualizerOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__Wrench[] = {  {&_swigt__p_iDynTree__Wrench, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t[] = {  {&_swigt__p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t[] = {  {&_swigt__p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iDynTree__estimateExternalWrenchesBuffers[] = {  {&_swigt__p_iDynTree__estimateExternalWrenchesBuffers, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_index_type[] = {  {&_swigt__p_index_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_iterator[] = {  {&_swigt__p_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_pointer[] = {  {&_swigt__p_pointer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_reference[] = {  {&_swigt__p_reference, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_reverse_iterator[] = {  {&_swigt__p_reverse_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_iDynTree__BerdyDynamicVariable_t[] = {  {&_swigt__p_std__allocatorT_iDynTree__BerdyDynamicVariable_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_iDynTree__BerdySensor_t[] = {  {&_swigt__p_std__allocatorT_iDynTree__BerdySensor_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t[] = {  {&_swigt__p_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_iDynTree__SolidShape_p_t[] = {  {&_swigt__p_std__allocatorT_iDynTree__SolidShape_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_int_t[] = {  {&_swigt__p_std__allocatorT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = {  {&_swigt__p_std__allocatorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t[] = {  {&_swigt__p_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ptrdiff_t[] = {  {&_swigt__p_std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t_t[] = {  {&_swigt__p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t_t[] = {  {&_swigt__p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__size_t[] = {  {&_swigt__p_std__size_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t[] = {  {&_swigt__p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t[] = {  {&_swigt__p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_iDynTree__MatrixDynSize_std__allocatorT_iDynTree__MatrixDynSize_t_t[] = {  {&_swigt__p_std__vectorT_iDynTree__MatrixDynSize_std__allocatorT_iDynTree__MatrixDynSize_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t[] = {  {&_swigt__p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_iDynTree__PixelViz_std__allocatorT_iDynTree__PixelViz_t_t[] = {  {&_swigt__p_std__vectorT_iDynTree__PixelViz_std__allocatorT_iDynTree__PixelViz_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_iDynTree__Polygon_std__allocatorT_iDynTree__Polygon_t_t[] = {  {&_swigt__p_std__vectorT_iDynTree__Polygon_std__allocatorT_iDynTree__Polygon_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_iDynTree__Position_std__allocatorT_iDynTree__Position_t_t[] = {  {&_swigt__p_std__vectorT_iDynTree__Position_std__allocatorT_iDynTree__Position_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t[] = {  {&_swigt__p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_iDynTree__Transform_std__allocatorT_iDynTree__Transform_t_t[] = {  {&_swigt__p_std__vectorT_iDynTree__Transform_std__allocatorT_iDynTree__Transform_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_iDynTree__VectorDynSize_std__allocatorT_iDynTree__VectorDynSize_t_t[] = {  {&_swigt__p_std__vectorT_iDynTree__VectorDynSize_std__allocatorT_iDynTree__VectorDynSize_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_iDynTree__VectorFixSizeT_2_t_std__allocatorT_iDynTree__VectorFixSizeT_2_t_t_t[] = {  {&_swigt__p_std__vectorT_iDynTree__VectorFixSizeT_2_t_std__allocatorT_iDynTree__VectorFixSizeT_2_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_iDynTree__VectorFixSizeT_6_t_std__allocatorT_iDynTree__VectorFixSizeT_6_t_t_t[] = {  {&_swigt__p_std__vectorT_iDynTree__VectorFixSizeT_6_t_std__allocatorT_iDynTree__VectorFixSizeT_6_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_int_std__allocatorT_int_t_t[] = {  {&_swigt__p_std__vectorT_int_std__allocatorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t[] = {  {&_swigt__p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__ptrdiff_t_std__allocatorT_std__ptrdiff_t_t_t[] = {  {&_swigt__p_std__vectorT_std__ptrdiff_t_std__allocatorT_std__ptrdiff_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = {  {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swig__MatlabSwigIterator[] = {  {&_swigt__p_swig__MatlabSwigIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_typed_iterator[] = {  {&_swigt__p_typed_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_AngularVector3T,
  _swigc__p_DualVectorT,
  _swigc__p_LinearVector3T,
  _swigc__p_Type,
  _swigc__p_allocator_type,
  _swigc__p_char,
  _swigc__p_const_iterator,
  _swigc__p_const_pointer,
  _swigc__p_const_reference,
  _swigc__p_const_reverse_iterator,
  _swigc__p_const_typed_iterator,
  _swigc__p_difference_type,
  _swigc__p_double,
  _swigc__p_element_type,
  _swigc__p_iDynTree__AccelerometerSensor,
  _swigc__p_iDynTree__ArticulatedBodyAlgorithmInternalBuffers,
  _swigc__p_iDynTree__ArticulatedBodyInertia,
  _swigc__p_iDynTree__AttitudeEstimatorState,
  _swigc__p_iDynTree__AttitudeMahonyFilter,
  _swigc__p_iDynTree__AttitudeMahonyFilterParameters,
  _swigc__p_iDynTree__AttitudeQuaternionEKF,
  _swigc__p_iDynTree__AttitudeQuaternionEKFParameters,
  _swigc__p_iDynTree__Axis,
  _swigc__p_iDynTree__BerdyDynamicVariable,
  _swigc__p_iDynTree__BerdyHelper,
  _swigc__p_iDynTree__BerdyOptions,
  _swigc__p_iDynTree__BerdySensor,
  _swigc__p_iDynTree__BerdySparseMAPSolver,
  _swigc__p_iDynTree__Box,
  _swigc__p_iDynTree__ClassicalAcc,
  _swigc__p_iDynTree__ColorViz,
  _swigc__p_iDynTree__ContactWrench,
  _swigc__p_iDynTree__ConvexHullProjectionConstraint,
  _swigc__p_iDynTree__Cylinder,
  _swigc__p_iDynTree__DOFSpatialForceArray,
  _swigc__p_iDynTree__DOFSpatialMotionArray,
  _swigc__p_iDynTree__Direction,
  _swigc__p_iDynTree__DiscreteExtendedKalmanFilterHelper,
  _swigc__p_iDynTree__Dummy,
  _swigc__p_iDynTree__ExtWrenchesAndJointTorquesEstimator,
  _swigc__p_iDynTree__ExternalMesh,
  _swigc__p_iDynTree__FixedJoint,
  _swigc__p_iDynTree__FrameFreeFloatingJacobian,
  _swigc__p_iDynTree__FreeFloatingAcc,
  _swigc__p_iDynTree__FreeFloatingGeneralizedTorques,
  _swigc__p_iDynTree__FreeFloatingMassMatrix,
  _swigc__p_iDynTree__FreeFloatingPos,
  _swigc__p_iDynTree__FreeFloatingVel,
  _swigc__p_iDynTree__GeomVector3,
  _swigc__p_iDynTree__GyroscopeSensor,
  _swigc__p_iDynTree__IAttitudeEstimator,
  _swigc__p_iDynTree__ICamera,
  _swigc__p_iDynTree__ICameraAnimator,
  _swigc__p_iDynTree__IEnvironment,
  _swigc__p_iDynTree__IFrameVisualization,
  _swigc__p_iDynTree__IJetsVisualization,
  _swigc__p_iDynTree__IJoint,
  _swigc__p_iDynTree__ILight,
  _swigc__p_iDynTree__IModelVisualization,
  _swigc__p_iDynTree__ITexture,
  _swigc__p_iDynTree__ITexturesHandler,
  _swigc__p_iDynTree__IVectorsVisualization,
  _swigc__p_iDynTree__IndexRange,
  _swigc__p_iDynTree__InverseKinematics,
  _swigc__p_iDynTree__JointDOFsDoubleArray,
  _swigc__p_iDynTree__JointPosDoubleArray,
  _swigc__p_iDynTree__JointSensor,
  _swigc__p_iDynTree__KinDynComputations,
  _swigc__p_iDynTree__Link,
  _swigc__p_iDynTree__LinkAccArray,
  _swigc__p_iDynTree__LinkArticulatedBodyInertias,
  _swigc__p_iDynTree__LinkContactWrenches,
  _swigc__p_iDynTree__LinkInertias,
  _swigc__p_iDynTree__LinkPositions,
  _swigc__p_iDynTree__LinkSensor,
  _swigc__p_iDynTree__LinkUnknownWrenchContacts,
  _swigc__p_iDynTree__LinkVelArray,
  _swigc__p_iDynTree__LinkWrenches,
  _swigc__p_iDynTree__Material,
  _swigc__p_iDynTree__MatrixDynSize,
  _swigc__p_iDynTree__MatrixFixSizeT_10_16_t,
  _swigc__p_iDynTree__MatrixFixSizeT_1_6_t,
  _swigc__p_iDynTree__MatrixFixSizeT_2_3_t,
  _swigc__p_iDynTree__MatrixFixSizeT_3_3_t,
  _swigc__p_iDynTree__MatrixFixSizeT_3_4_t,
  _swigc__p_iDynTree__MatrixFixSizeT_4_3_t,
  _swigc__p_iDynTree__MatrixFixSizeT_4_4_t,
  _swigc__p_iDynTree__MatrixFixSizeT_6_10_t,
  _swigc__p_iDynTree__MatrixFixSizeT_6_1_t,
  _swigc__p_iDynTree__MatrixFixSizeT_6_6_t,
  _swigc__p_iDynTree__MatrixViewT_double_const_t,
  _swigc__p_iDynTree__MatrixViewT_double_t,
  _swigc__p_iDynTree__Model,
  _swigc__p_iDynTree__ModelCalibrationHelper,
  _swigc__p_iDynTree__ModelExporter,
  _swigc__p_iDynTree__ModelExporterOptions,
  _swigc__p_iDynTree__ModelLoader,
  _swigc__p_iDynTree__ModelParserOptions,
  _swigc__p_iDynTree__ModelSolidShapes,
  _swigc__p_iDynTree__MomentumFreeFloatingJacobian,
  _swigc__p_iDynTree__MovableJointImplT_1_1_t,
  _swigc__p_iDynTree__MovableJointImplT_2_2_t,
  _swigc__p_iDynTree__MovableJointImplT_3_3_t,
  _swigc__p_iDynTree__MovableJointImplT_4_4_t,
  _swigc__p_iDynTree__MovableJointImplT_5_5_t,
  _swigc__p_iDynTree__MovableJointImplT_6_6_t,
  _swigc__p_iDynTree__Neighbor,
  _swigc__p_iDynTree__PixelViz,
  _swigc__p_iDynTree__Polygon,
  _swigc__p_iDynTree__Polygon2D,
  _swigc__p_iDynTree__Position,
  _swigc__p_iDynTree__PositionRaw,
  _swigc__p_iDynTree__PrismaticJoint,
  _swigc__p_iDynTree__RevoluteJoint,
  _swigc__p_iDynTree__RigidBodyInertiaNonLinearParametrization,
  _swigc__p_iDynTree__Rotation,
  _swigc__p_iDynTree__RotationRaw,
  _swigc__p_iDynTree__RotationalInertiaRaw,
  _swigc__p_iDynTree__Sensor,
  _swigc__p_iDynTree__SensorsList,
  _swigc__p_iDynTree__SensorsMeasurements,
  _swigc__p_iDynTree__SimpleLeggedOdometry,
  _swigc__p_iDynTree__SixAxisForceTorqueSensor,
  _swigc__p_iDynTree__SolidShape,
  _swigc__p_iDynTree__SpanT_double__1_t,
  _swigc__p_iDynTree__SpanT_double_const__1_t,
  _swigc__p_iDynTree__SparseMatrixT_iDynTree__ColumnMajor_t,
  _swigc__p_iDynTree__SparseMatrixT_iDynTree__RowMajor_t,
  _swigc__p_iDynTree__SpatialAcc,
  _swigc__p_iDynTree__SpatialForceVector,
  _swigc__p_iDynTree__SpatialInertia,
  _swigc__p_iDynTree__SpatialInertiaRaw,
  _swigc__p_iDynTree__SpatialMomentum,
  _swigc__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__AngularVector3Type,
  _swigc__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialForceVector_t__LinearVector3Type,
  _swigc__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__AngularVector3Type,
  _swigc__p_iDynTree__SpatialMotionForceVectorT_traitsT_iDynTree__SpatialMotionVector_t__LinearVector3Type,
  _swigc__p_iDynTree__SpatialMotionVector,
  _swigc__p_iDynTree__SpatialVectorT_iDynTree__SpatialForceVector_t,
  _swigc__p_iDynTree__SpatialVectorT_iDynTree__SpatialMotionVector_t,
  _swigc__p_iDynTree__Sphere,
  _swigc__p_iDynTree__SubModelDecomposition,
  _swigc__p_iDynTree__ThreeAxisAngularAccelerometerSensor,
  _swigc__p_iDynTree__ThreeAxisForceTorqueContactSensor,
  _swigc__p_iDynTree__Transform,
  _swigc__p_iDynTree__TransformDerivative,
  _swigc__p_iDynTree__Traversal,
  _swigc__p_iDynTree__Triplets,
  _swigc__p_iDynTree__Twist,
  _swigc__p_iDynTree__UnknownWrenchContact,
  _swigc__p_iDynTree__VectorDynSize,
  _swigc__p_iDynTree__VectorFixSizeT_10_t,
  _swigc__p_iDynTree__VectorFixSizeT_16_t,
  _swigc__p_iDynTree__VectorFixSizeT_2_t,
  _swigc__p_iDynTree__VectorFixSizeT_3_t,
  _swigc__p_iDynTree__VectorFixSizeT_4_t,
  _swigc__p_iDynTree__VectorFixSizeT_6_t,
  _swigc__p_iDynTree__Visualizer,
  _swigc__p_iDynTree__VisualizerOptions,
  _swigc__p_iDynTree__Wrench,
  _swigc__p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t,
  _swigc__p_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t,
  _swigc__p_iDynTree__estimateExternalWrenchesBuffers,
  _swigc__p_index_type,
  _swigc__p_iterator,
  _swigc__p_pointer,
  _swigc__p_reference,
  _swigc__p_reverse_iterator,
  _swigc__p_size_type,
  _swigc__p_std__allocatorT_iDynTree__BerdyDynamicVariable_t,
  _swigc__p_std__allocatorT_iDynTree__BerdySensor_t,
  _swigc__p_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t,
  _swigc__p_std__allocatorT_iDynTree__SolidShape_p_t,
  _swigc__p_std__allocatorT_int_t,
  _swigc__p_std__allocatorT_std__string_t,
  _swigc__p_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t,
  _swigc__p_std__ptrdiff_t,
  _swigc__p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_false_t_t,
  _swigc__p_std__reverse_iteratorT_iDynTree__details__span_iteratorT_iDynTree__SpanT_double__1_t_true_t_t,
  _swigc__p_std__size_t,
  _swigc__p_std__string,
  _swigc__p_std__vectorT_iDynTree__BerdyDynamicVariable_std__allocatorT_iDynTree__BerdyDynamicVariable_t_t,
  _swigc__p_std__vectorT_iDynTree__BerdySensor_std__allocatorT_iDynTree__BerdySensor_t_t,
  _swigc__p_std__vectorT_iDynTree__MatrixDynSize_std__allocatorT_iDynTree__MatrixDynSize_t_t,
  _swigc__p_std__vectorT_iDynTree__MatrixFixSizeT_4_4_t_std__allocatorT_iDynTree__MatrixFixSizeT_4_4_t_t_t,
  _swigc__p_std__vectorT_iDynTree__PixelViz_std__allocatorT_iDynTree__PixelViz_t_t,
  _swigc__p_std__vectorT_iDynTree__Polygon_std__allocatorT_iDynTree__Polygon_t_t,
  _swigc__p_std__vectorT_iDynTree__Position_std__allocatorT_iDynTree__Position_t_t,
  _swigc__p_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t,
  _swigc__p_std__vectorT_iDynTree__Transform_std__allocatorT_iDynTree__Transform_t_t,
  _swigc__p_std__vectorT_iDynTree__VectorDynSize_std__allocatorT_iDynTree__VectorDynSize_t_t,
  _swigc__p_std__vectorT_iDynTree__VectorFixSizeT_2_t_std__allocatorT_iDynTree__VectorFixSizeT_2_t_t_t,
  _swigc__p_std__vectorT_iDynTree__VectorFixSizeT_6_t_std__allocatorT_iDynTree__VectorFixSizeT_6_t_t_t,
  _swigc__p_std__vectorT_int_std__allocatorT_int_t_t,
  _swigc__p_std__vectorT_std__pairT_double_double_t_std__allocatorT_std__pairT_double_double_t_t_t,
  _swigc__p_std__vectorT_std__ptrdiff_t_std__allocatorT_std__ptrdiff_t_t_t,
  _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
  _swigc__p_std__vectorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_std__allocatorT_std__vectorT_iDynTree__SolidShape_p_std__allocatorT_iDynTree__SolidShape_p_t_t_t_t,
  _swigc__p_swig__MatlabSwigIterator,
  _swigc__p_typed_iterator,
  _swigc__p_unsigned_int,
  _swigc__p_value_type,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;

  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }

  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);

    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }

  /* When multiple interpreters are used, a module could have already been initialized in
     a different interpreter, but not yet have a pointer in this interpreter.
     In this case, we do not want to continue adding types... everything should be
     set up already */
  if (init == 0) return;

  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;

#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
#endif

    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
	type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }

    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {

      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
	if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
	  cast->type = ret;
	  ret = 0;
	} else {
	  /* Check for casting already in the list */
	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
	  if (!ocast) ret = 0;
	}
      }

      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;

#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
  printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;

  if (init_run) return;
  init_run = 1;

  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
            SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{ /* c-mode */
#endif
}
#endif


void SWIG_Matlab_LoadModule() {
  /* Only call once */
  static int moduleIsLoaded = 0;
  if (moduleIsLoaded) return;
  moduleIsLoaded = 1;

  /* Prevent unloading this file until MATLAB exits */
  mexLock();

  /* Exit function (called when unloaded) */
  mexAtExit(SWIG_Matlab_ExitFcn);

  /* Load dependent modules and initialize */

SWIG_InitializeModule(0);

}


SWIGINTERN const char* SwigConstantName(int con_id) {
  switch (con_id) {
  case 0: return "RowMajor";
  case 1: return "ColumnMajor";
  case 2: return "INERTIAL_FIXED_REPRESENTATION";
  case 3: return "BODY_FIXED_REPRESENTATION";
  case 4: return "MIXED_REPRESENTATION";
  case 5: return "SIX_AXIS_FORCE_TORQUE";
  case 6: return "ACCELEROMETER";
  case 7: return "GYROSCOPE";
  case 8: return "THREE_AXIS_ANGULAR_ACCELEROMETER";
  case 9: return "THREE_AXIS_FORCE_TORQUE_CONTACT";
  case 10: return "FULL_WRENCH";
  case 11: return "PURE_FORCE";
  case 12: return "PURE_FORCE_WITH_KNOWN_DIRECTION";
  case 13: return "NO_UNKNOWNS";
  case 14: return "ORIGINAL_BERDY_FIXED_BASE";
  case 15: return "BERDY_FLOATING_BASE";
  case 16: return "LINK_BODY_PROPER_ACCELERATION";
  case 17: return "NET_INT_AND_EXT_WRENCHES_ON_LINK_WITHOUT_GRAV";
  case 18: return "JOINT_WRENCH";
  case 19: return "DOF_TORQUE";
  case 20: return "NET_EXT_WRENCH";
  case 21: return "DOF_ACCELERATION";
  case 22: return "LINK_BODY_PROPER_CLASSICAL_ACCELERATION";
  case 23: return "SIX_AXIS_FORCE_TORQUE_SENSOR";
  case 24: return "ACCELEROMETER_SENSOR";
  case 25: return "GYROSCOPE_SENSOR";
  case 26: return "THREE_AXIS_ANGULAR_ACCELEROMETER_SENSOR";
  case 27: return "THREE_AXIS_FORCE_TORQUE_CONTACT_SENSOR";
  case 28: return "DOF_ACCELERATION_SENSOR";
  case 29: return "DOF_TORQUE_SENSOR";
  case 30: return "NET_EXT_WRENCH_SENSOR";
  case 31: return "JOINT_WRENCH_SENSOR";
  case 32: return "POINT_LIGHT";
  case 33: return "DIRECTIONAL_LIGHT";
  case 34: return "InverseKinematicsRotationParametrizationQuaternion";
  case 35: return "InverseKinematicsRotationParametrizationRollPitchYaw";
  case 36: return "InverseKinematicsTreatTargetAsConstraintNone";
  case 37: return "InverseKinematicsTreatTargetAsConstraintPositionOnly";
  case 38: return "InverseKinematicsTreatTargetAsConstraintRotationOnly";
  case 39: return "InverseKinematicsTreatTargetAsConstraintFull";
  default: return 0;
  }
}

SWIGINTERN int swigConstantName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc!=1 || !mxIsDouble(*argv) || mxGetNumberOfElements(*argv)!=1) {
    SWIG_Error(SWIG_RuntimeError, "This mex file should only be called from inside the .m files generated by SWIG. The input should be the constant ID.");
    return 1;
  }
  if (resc!=1) {
    SWIG_Error(SWIG_RuntimeError, "The function should have one output.");
    return 1;
  }
  int con_id = (int)mxGetScalar(*argv);
  const char* s = SwigConstantName(con_id);
  if (s==0) {
    SWIG_Error(SWIG_RuntimeError, "No such constant ID.");
    return 1;
  }
  *resv = mxCreateString(s);
  return 0;
}

SWIGINTERN int swigConstant(int SWIGUNUSEDPARM(resc), mxArray *resv[], int argc, mxArray *argv[]) {
  if (--argc < 0 || !mxIsDouble(*argv) || mxGetNumberOfElements(*argv)!=1) {
    SWIG_Error(SWIG_RuntimeError, "This function should only be called from inside the .m files generated by SWIG. First input should be the constant ID .");
    return 1;
  }
  int con_id = (int)mxGetScalar(*argv++);
  switch (con_id) {
  case 0: *resv = SWIG_Matlab_SetConstant(module_ns,"RowMajor",SWIG_From_int(static_cast< int >(iDynTree::RowMajor)));; break;
  case 1: *resv = SWIG_Matlab_SetConstant(module_ns,"ColumnMajor",SWIG_From_int(static_cast< int >(iDynTree::ColumnMajor)));; break;
  case 2: *resv = SWIG_Matlab_SetConstant(module_ns,"INERTIAL_FIXED_REPRESENTATION",SWIG_From_int(static_cast< int >(iDynTree::INERTIAL_FIXED_REPRESENTATION)));; break;
  case 3: *resv = SWIG_Matlab_SetConstant(module_ns,"BODY_FIXED_REPRESENTATION",SWIG_From_int(static_cast< int >(iDynTree::BODY_FIXED_REPRESENTATION)));; break;
  case 4: *resv = SWIG_Matlab_SetConstant(module_ns,"MIXED_REPRESENTATION",SWIG_From_int(static_cast< int >(iDynTree::MIXED_REPRESENTATION)));; break;
  case 5: *resv = SWIG_Matlab_SetConstant(module_ns,"SIX_AXIS_FORCE_TORQUE",SWIG_From_int(static_cast< int >(iDynTree::SIX_AXIS_FORCE_TORQUE)));; break;
  case 6: *resv = SWIG_Matlab_SetConstant(module_ns,"ACCELEROMETER",SWIG_From_int(static_cast< int >(iDynTree::ACCELEROMETER)));; break;
  case 7: *resv = SWIG_Matlab_SetConstant(module_ns,"GYROSCOPE",SWIG_From_int(static_cast< int >(iDynTree::GYROSCOPE)));; break;
  case 8: *resv = SWIG_Matlab_SetConstant(module_ns,"THREE_AXIS_ANGULAR_ACCELEROMETER",SWIG_From_int(static_cast< int >(iDynTree::THREE_AXIS_ANGULAR_ACCELEROMETER)));; break;
  case 9: *resv = SWIG_Matlab_SetConstant(module_ns,"THREE_AXIS_FORCE_TORQUE_CONTACT",SWIG_From_int(static_cast< int >(iDynTree::THREE_AXIS_FORCE_TORQUE_CONTACT)));; break;
  case 10: *resv = SWIG_Matlab_SetConstant(module_ns,"FULL_WRENCH",SWIG_From_int(static_cast< int >(iDynTree::FULL_WRENCH)));; break;
  case 11: *resv = SWIG_Matlab_SetConstant(module_ns,"PURE_FORCE",SWIG_From_int(static_cast< int >(iDynTree::PURE_FORCE)));; break;
  case 12: *resv = SWIG_Matlab_SetConstant(module_ns,"PURE_FORCE_WITH_KNOWN_DIRECTION",SWIG_From_int(static_cast< int >(iDynTree::PURE_FORCE_WITH_KNOWN_DIRECTION)));; break;
  case 13: *resv = SWIG_Matlab_SetConstant(module_ns,"NO_UNKNOWNS",SWIG_From_int(static_cast< int >(iDynTree::NO_UNKNOWNS)));; break;
  case 14: *resv = SWIG_Matlab_SetConstant(module_ns,"ORIGINAL_BERDY_FIXED_BASE",SWIG_From_int(static_cast< int >(iDynTree::ORIGINAL_BERDY_FIXED_BASE)));; break;
  case 15: *resv = SWIG_Matlab_SetConstant(module_ns,"BERDY_FLOATING_BASE",SWIG_From_int(static_cast< int >(iDynTree::BERDY_FLOATING_BASE)));; break;
  case 16: *resv = SWIG_Matlab_SetConstant(module_ns,"LINK_BODY_PROPER_ACCELERATION",SWIG_From_int(static_cast< int >(iDynTree::LINK_BODY_PROPER_ACCELERATION)));; break;
  case 17: *resv = SWIG_Matlab_SetConstant(module_ns,"NET_INT_AND_EXT_WRENCHES_ON_LINK_WITHOUT_GRAV",SWIG_From_int(static_cast< int >(iDynTree::NET_INT_AND_EXT_WRENCHES_ON_LINK_WITHOUT_GRAV)));; break;
  case 18: *resv = SWIG_Matlab_SetConstant(module_ns,"JOINT_WRENCH",SWIG_From_int(static_cast< int >(iDynTree::JOINT_WRENCH)));; break;
  case 19: *resv = SWIG_Matlab_SetConstant(module_ns,"DOF_TORQUE",SWIG_From_int(static_cast< int >(iDynTree::DOF_TORQUE)));; break;
  case 20: *resv = SWIG_Matlab_SetConstant(module_ns,"NET_EXT_WRENCH",SWIG_From_int(static_cast< int >(iDynTree::NET_EXT_WRENCH)));; break;
  case 21: *resv = SWIG_Matlab_SetConstant(module_ns,"DOF_ACCELERATION",SWIG_From_int(static_cast< int >(iDynTree::DOF_ACCELERATION)));; break;
  case 22: *resv = SWIG_Matlab_SetConstant(module_ns,"LINK_BODY_PROPER_CLASSICAL_ACCELERATION",SWIG_From_int(static_cast< int >(iDynTree::LINK_BODY_PROPER_CLASSICAL_ACCELERATION)));; break;
  case 23: *resv = SWIG_Matlab_SetConstant(module_ns,"SIX_AXIS_FORCE_TORQUE_SENSOR",SWIG_From_int(static_cast< int >(iDynTree::SIX_AXIS_FORCE_TORQUE_SENSOR)));; break;
  case 24: *resv = SWIG_Matlab_SetConstant(module_ns,"ACCELEROMETER_SENSOR",SWIG_From_int(static_cast< int >(iDynTree::ACCELEROMETER_SENSOR)));; break;
  case 25: *resv = SWIG_Matlab_SetConstant(module_ns,"GYROSCOPE_SENSOR",SWIG_From_int(static_cast< int >(iDynTree::GYROSCOPE_SENSOR)));; break;
  case 26: *resv = SWIG_Matlab_SetConstant(module_ns,"THREE_AXIS_ANGULAR_ACCELEROMETER_SENSOR",SWIG_From_int(static_cast< int >(iDynTree::THREE_AXIS_ANGULAR_ACCELEROMETER_SENSOR)));; break;
  case 27: *resv = SWIG_Matlab_SetConstant(module_ns,"THREE_AXIS_FORCE_TORQUE_CONTACT_SENSOR",SWIG_From_int(static_cast< int >(iDynTree::THREE_AXIS_FORCE_TORQUE_CONTACT_SENSOR)));; break;
  case 28: *resv = SWIG_Matlab_SetConstant(module_ns,"DOF_ACCELERATION_SENSOR",SWIG_From_int(static_cast< int >(iDynTree::DOF_ACCELERATION_SENSOR)));; break;
  case 29: *resv = SWIG_Matlab_SetConstant(module_ns,"DOF_TORQUE_SENSOR",SWIG_From_int(static_cast< int >(iDynTree::DOF_TORQUE_SENSOR)));; break;
  case 30: *resv = SWIG_Matlab_SetConstant(module_ns,"NET_EXT_WRENCH_SENSOR",SWIG_From_int(static_cast< int >(iDynTree::NET_EXT_WRENCH_SENSOR)));; break;
  case 31: *resv = SWIG_Matlab_SetConstant(module_ns,"JOINT_WRENCH_SENSOR",SWIG_From_int(static_cast< int >(iDynTree::JOINT_WRENCH_SENSOR)));; break;
  case 32: *resv = SWIG_Matlab_SetConstant(module_ns,"POINT_LIGHT",SWIG_From_int(static_cast< int >(iDynTree::POINT_LIGHT)));; break;
  case 33: *resv = SWIG_Matlab_SetConstant(module_ns,"DIRECTIONAL_LIGHT",SWIG_From_int(static_cast< int >(iDynTree::DIRECTIONAL_LIGHT)));; break;
  case 34: *resv = SWIG_Matlab_SetConstant(module_ns,"InverseKinematicsRotationParametrizationQuaternion",SWIG_From_int(static_cast< int >(iDynTree::InverseKinematicsRotationParametrizationQuaternion)));; break;
  case 35: *resv = SWIG_Matlab_SetConstant(module_ns,"InverseKinematicsRotationParametrizationRollPitchYaw",SWIG_From_int(static_cast< int >(iDynTree::InverseKinematicsRotationParametrizationRollPitchYaw)));; break;
  case 36: *resv = SWIG_Matlab_SetConstant(module_ns,"InverseKinematicsTreatTargetAsConstraintNone",SWIG_From_int(static_cast< int >(iDynTree::InverseKinematicsTreatTargetAsConstraintNone)));; break;
  case 37: *resv = SWIG_Matlab_SetConstant(module_ns,"InverseKinematicsTreatTargetAsConstraintPositionOnly",SWIG_From_int(static_cast< int >(iDynTree::InverseKinematicsTreatTargetAsConstraintPositionOnly)));; break;
  case 38: *resv = SWIG_Matlab_SetConstant(module_ns,"InverseKinematicsTreatTargetAsConstraintRotationOnly",SWIG_From_int(static_cast< int >(iDynTree::InverseKinematicsTreatTargetAsConstraintRotationOnly)));; break;
  case 39: *resv = SWIG_Matlab_SetConstant(module_ns,"InverseKinematicsTreatTargetAsConstraintFull",SWIG_From_int(static_cast< int >(iDynTree::InverseKinematicsTreatTargetAsConstraintFull)));; break;
  default:
    SWIG_Error(SWIG_RuntimeError, "No such constant.");
    return 1;
  }
  return 0;
}

SWIGINTERN const char* SwigFunctionName(int fcn_id) {
  switch(fcn_id) {
  case 0: return "swigConstant";
  case 1: return "swigFunctionName";
  case 2: return "swigConstantName";
  case 3: return "swigThis";
  case 4: return "swigTouch";
  case 5: return "delete_MatlabSwigIterator";
  case 6: return "MatlabSwigIterator_value";
  case 7: return "MatlabSwigIterator_incr";
  case 8: return "MatlabSwigIterator_decr";
  case 9: return "MatlabSwigIterator_distance";
  case 10: return "MatlabSwigIterator_equal";
  case 11: return "MatlabSwigIterator_copy";
  case 12: return "MatlabSwigIterator_next";
  case 13: return "MatlabSwigIterator_previous";
  case 14: return "MatlabSwigIterator_advance";
  case 15: return "MatlabSwigIterator_eq";
  case 16: return "MatlabSwigIterator_ne";
  case 17: return "MatlabSwigIterator_TODOincr";
  case 18: return "MatlabSwigIterator_TODOdecr";
  case 19: return "MatlabSwigIterator_plus";
  case 20: return "MatlabSwigIterator_minus";
  case 21: return "StringVector_pop";
  case 22: return "StringVector_brace";
  case 23: return "StringVector_setbrace";
  case 24: return "StringVector_append";
  case 25: return "StringVector_empty";
  case 26: return "StringVector_size";
  case 27: return "StringVector_swap";
  case 28: return "StringVector_begin";
  case 29: return "StringVector_end";
  case 30: return "StringVector_rbegin";
  case 31: return "StringVector_rend";
  case 32: return "StringVector_clear";
  case 33: return "StringVector_get_allocator";
  case 34: return "StringVector_pop_back";
  case 35: return "StringVector_erase";
  case 36: return "new_StringVector";
  case 37: return "StringVector_push_back";
  case 38: return "StringVector_front";
  case 39: return "StringVector_back";
  case 40: return "StringVector_assign";
  case 41: return "StringVector_resize";
  case 42: return "StringVector_insert";
  case 43: return "StringVector_reserve";
  case 44: return "StringVector_capacity";
  case 45: return "delete_StringVector";
  case 46: return "IntVector_pop";
  case 47: return "IntVector_brace";
  case 48: return "IntVector_setbrace";
  case 49: return "IntVector_append";
  case 50: return "IntVector_empty";
  case 51: return "IntVector_size";
  case 52: return "IntVector_swap";
  case 53: return "IntVector_begin";
  case 54: return "IntVector_end";
  case 55: return "IntVector_rbegin";
  case 56: return "IntVector_rend";
  case 57: return "IntVector_clear";
  case 58: return "IntVector_get_allocator";
  case 59: return "IntVector_pop_back";
  case 60: return "IntVector_erase";
  case 61: return "new_IntVector";
  case 62: return "IntVector_push_back";
  case 63: return "IntVector_front";
  case 64: return "IntVector_back";
  case 65: return "IntVector_assign";
  case 66: return "IntVector_resize";
  case 67: return "IntVector_insert";
  case 68: return "IntVector_reserve";
  case 69: return "IntVector_capacity";
  case 70: return "delete_IntVector";
  case 71: return "BerdySensors_pop";
  case 72: return "BerdySensors_brace";
  case 73: return "BerdySensors_setbrace";
  case 74: return "BerdySensors_append";
  case 75: return "BerdySensors_empty";
  case 76: return "BerdySensors_size";
  case 77: return "BerdySensors_swap";
  case 78: return "BerdySensors_begin";
  case 79: return "BerdySensors_end";
  case 80: return "BerdySensors_rbegin";
  case 81: return "BerdySensors_rend";
  case 82: return "BerdySensors_clear";
  case 83: return "BerdySensors_get_allocator";
  case 84: return "BerdySensors_pop_back";
  case 85: return "BerdySensors_erase";
  case 86: return "new_BerdySensors";
  case 87: return "BerdySensors_push_back";
  case 88: return "BerdySensors_front";
  case 89: return "BerdySensors_back";
  case 90: return "BerdySensors_assign";
  case 91: return "BerdySensors_resize";
  case 92: return "BerdySensors_insert";
  case 93: return "BerdySensors_reserve";
  case 94: return "BerdySensors_capacity";
  case 95: return "delete_BerdySensors";
  case 96: return "BerdyDynamicVariables_pop";
  case 97: return "BerdyDynamicVariables_brace";
  case 98: return "BerdyDynamicVariables_setbrace";
  case 99: return "BerdyDynamicVariables_append";
  case 100: return "BerdyDynamicVariables_empty";
  case 101: return "BerdyDynamicVariables_size";
  case 102: return "BerdyDynamicVariables_swap";
  case 103: return "BerdyDynamicVariables_begin";
  case 104: return "BerdyDynamicVariables_end";
  case 105: return "BerdyDynamicVariables_rbegin";
  case 106: return "BerdyDynamicVariables_rend";
  case 107: return "BerdyDynamicVariables_clear";
  case 108: return "BerdyDynamicVariables_get_allocator";
  case 109: return "BerdyDynamicVariables_pop_back";
  case 110: return "BerdyDynamicVariables_erase";
  case 111: return "new_BerdyDynamicVariables";
  case 112: return "BerdyDynamicVariables_push_back";
  case 113: return "BerdyDynamicVariables_front";
  case 114: return "BerdyDynamicVariables_back";
  case 115: return "BerdyDynamicVariables_assign";
  case 116: return "BerdyDynamicVariables_resize";
  case 117: return "BerdyDynamicVariables_insert";
  case 118: return "BerdyDynamicVariables_reserve";
  case 119: return "BerdyDynamicVariables_capacity";
  case 120: return "delete_BerdyDynamicVariables";
  case 121: return "_wrap_reportInfo";
  case 122: return "_wrap_reportDebug";
  case 123: return "IndexRange_offset_get";
  case 124: return "IndexRange_offset_set";
  case 125: return "IndexRange_size_get";
  case 126: return "IndexRange_size_set";
  case 127: return "IndexRange_isValid";
  case 128: return "IndexRange_InvalidRange";
  case 129: return "new_IndexRange";
  case 130: return "delete_IndexRange";
  case 131: return "_wrap_checkDoublesAreEqual";
  case 132: return "new_MatrixDynSize";
  case 133: return "delete_MatrixDynSize";
  case 134: return "MatrixDynSize_paren";
  case 135: return "MatrixDynSize_getVal";
  case 136: return "MatrixDynSize_setVal";
  case 137: return "MatrixDynSize_rows";
  case 138: return "MatrixDynSize_cols";
  case 139: return "MatrixDynSize_data";
  case 140: return "MatrixDynSize_zero";
  case 141: return "MatrixDynSize_resize";
  case 142: return "MatrixDynSize_reserve";
  case 143: return "MatrixDynSize_capacity";
  case 144: return "MatrixDynSize_shrink_to_fit";
  case 145: return "MatrixDynSize_fillRowMajorBuffer";
  case 146: return "MatrixDynSize_fillColMajorBuffer";
  case 147: return "MatrixDynSize_toString";
  case 148: return "MatrixDynSize_display";
  case 149: return "MatrixDynSize_toMatlab";
  case 150: return "MatrixDynSize_fromMatlab";
  case 151: return "new_SparseMatrixRowMajor";
  case 152: return "delete_SparseMatrixRowMajor";
  case 153: return "SparseMatrixRowMajor_numberOfNonZeros";
  case 154: return "SparseMatrixRowMajor_resize";
  case 155: return "SparseMatrixRowMajor_reserve";
  case 156: return "SparseMatrixRowMajor_zero";
  case 157: return "SparseMatrixRowMajor_setFromConstTriplets";
  case 158: return "SparseMatrixRowMajor_setFromTriplets";
  case 159: return "SparseMatrixRowMajor_sparseMatrixFromTriplets";
  case 160: return "SparseMatrixRowMajor_paren";
  case 161: return "SparseMatrixRowMajor_getValue";
  case 162: return "SparseMatrixRowMajor_setValue";
  case 163: return "SparseMatrixRowMajor_rows";
  case 164: return "SparseMatrixRowMajor_columns";
  case 165: return "SparseMatrixRowMajor_description";
  case 166: return "SparseMatrixRowMajor_toMatlab";
  case 167: return "SparseMatrixRowMajor_toMatlabDense";
  case 168: return "SparseMatrixRowMajor_fromMatlab";
  case 169: return "new_SparseMatrixColMajor";
  case 170: return "delete_SparseMatrixColMajor";
  case 171: return "SparseMatrixColMajor_numberOfNonZeros";
  case 172: return "SparseMatrixColMajor_resize";
  case 173: return "SparseMatrixColMajor_reserve";
  case 174: return "SparseMatrixColMajor_zero";
  case 175: return "SparseMatrixColMajor_setFromConstTriplets";
  case 176: return "SparseMatrixColMajor_setFromTriplets";
  case 177: return "SparseMatrixColMajor_sparseMatrixFromTriplets";
  case 178: return "SparseMatrixColMajor_paren";
  case 179: return "SparseMatrixColMajor_getValue";
  case 180: return "SparseMatrixColMajor_setValue";
  case 181: return "SparseMatrixColMajor_rows";
  case 182: return "SparseMatrixColMajor_columns";
  case 183: return "SparseMatrixColMajor_description";
  case 184: return "SparseMatrixColMajor_toMatlab";
  case 185: return "SparseMatrixColMajor_toMatlabDense";
  case 186: return "SparseMatrixColMajor_fromMatlab";
  case 187: return "new_VectorDynSize";
  case 188: return "delete_VectorDynSize";
  case 189: return "VectorDynSize_paren";
  case 190: return "VectorDynSize_brace";
  case 191: return "VectorDynSize_getVal";
  case 192: return "VectorDynSize_setVal";
  case 193: return "VectorDynSize_cbegin";
  case 194: return "VectorDynSize_cend";
  case 195: return "VectorDynSize_begin";
  case 196: return "VectorDynSize_end";
  case 197: return "VectorDynSize_size";
  case 198: return "VectorDynSize_data";
  case 199: return "VectorDynSize_zero";
  case 200: return "VectorDynSize_reserve";
  case 201: return "VectorDynSize_resize";
  case 202: return "VectorDynSize_shrink_to_fit";
  case 203: return "VectorDynSize_capacity";
  case 204: return "VectorDynSize_fillBuffer";
  case 205: return "VectorDynSize_toString";
  case 206: return "VectorDynSize_display";
  case 207: return "VectorDynSize_toMatlab";
  case 208: return "VectorDynSize_fromMatlab";
  case 209: return "new_Matrix1x6";
  case 210: return "Matrix1x6_paren";
  case 211: return "Matrix1x6_getVal";
  case 212: return "Matrix1x6_setVal";
  case 213: return "Matrix1x6_rows";
  case 214: return "Matrix1x6_cols";
  case 215: return "Matrix1x6_data";
  case 216: return "Matrix1x6_zero";
  case 217: return "Matrix1x6_fillRowMajorBuffer";
  case 218: return "Matrix1x6_fillColMajorBuffer";
  case 219: return "Matrix1x6_toString";
  case 220: return "Matrix1x6_display";
  case 221: return "Matrix1x6_toMatlab";
  case 222: return "Matrix1x6_fromMatlab";
  case 223: return "delete_Matrix1x6";
  case 224: return "new_Matrix2x3";
  case 225: return "Matrix2x3_paren";
  case 226: return "Matrix2x3_getVal";
  case 227: return "Matrix2x3_setVal";
  case 228: return "Matrix2x3_rows";
  case 229: return "Matrix2x3_cols";
  case 230: return "Matrix2x3_data";
  case 231: return "Matrix2x3_zero";
  case 232: return "Matrix2x3_fillRowMajorBuffer";
  case 233: return "Matrix2x3_fillColMajorBuffer";
  case 234: return "Matrix2x3_toString";
  case 235: return "Matrix2x3_display";
  case 236: return "Matrix2x3_toMatlab";
  case 237: return "Matrix2x3_fromMatlab";
  case 238: return "delete_Matrix2x3";
  case 239: return "new_Matrix3x3";
  case 240: return "Matrix3x3_paren";
  case 241: return "Matrix3x3_getVal";
  case 242: return "Matrix3x3_setVal";
  case 243: return "Matrix3x3_rows";
  case 244: return "Matrix3x3_cols";
  case 245: return "Matrix3x3_data";
  case 246: return "Matrix3x3_zero";
  case 247: return "Matrix3x3_fillRowMajorBuffer";
  case 248: return "Matrix3x3_fillColMajorBuffer";
  case 249: return "Matrix3x3_toString";
  case 250: return "Matrix3x3_display";
  case 251: return "Matrix3x3_toMatlab";
  case 252: return "Matrix3x3_fromMatlab";
  case 253: return "delete_Matrix3x3";
  case 254: return "new_Matrix4x4";
  case 255: return "Matrix4x4_paren";
  case 256: return "Matrix4x4_getVal";
  case 257: return "Matrix4x4_setVal";
  case 258: return "Matrix4x4_rows";
  case 259: return "Matrix4x4_cols";
  case 260: return "Matrix4x4_data";
  case 261: return "Matrix4x4_zero";
  case 262: return "Matrix4x4_fillRowMajorBuffer";
  case 263: return "Matrix4x4_fillColMajorBuffer";
  case 264: return "Matrix4x4_toString";
  case 265: return "Matrix4x4_display";
  case 266: return "Matrix4x4_toMatlab";
  case 267: return "Matrix4x4_fromMatlab";
  case 268: return "delete_Matrix4x4";
  case 269: return "new_Matrix6x6";
  case 270: return "Matrix6x6_paren";
  case 271: return "Matrix6x6_getVal";
  case 272: return "Matrix6x6_setVal";
  case 273: return "Matrix6x6_rows";
  case 274: return "Matrix6x6_cols";
  case 275: return "Matrix6x6_data";
  case 276: return "Matrix6x6_zero";
  case 277: return "Matrix6x6_fillRowMajorBuffer";
  case 278: return "Matrix6x6_fillColMajorBuffer";
  case 279: return "Matrix6x6_toString";
  case 280: return "Matrix6x6_display";
  case 281: return "Matrix6x6_toMatlab";
  case 282: return "Matrix6x6_fromMatlab";
  case 283: return "delete_Matrix6x6";
  case 284: return "new_Matrix6x10";
  case 285: return "Matrix6x10_paren";
  case 286: return "Matrix6x10_getVal";
  case 287: return "Matrix6x10_setVal";
  case 288: return "Matrix6x10_rows";
  case 289: return "Matrix6x10_cols";
  case 290: return "Matrix6x10_data";
  case 291: return "Matrix6x10_zero";
  case 292: return "Matrix6x10_fillRowMajorBuffer";
  case 293: return "Matrix6x10_fillColMajorBuffer";
  case 294: return "Matrix6x10_toString";
  case 295: return "Matrix6x10_display";
  case 296: return "Matrix6x10_toMatlab";
  case 297: return "Matrix6x10_fromMatlab";
  case 298: return "delete_Matrix6x10";
  case 299: return "new_Matrix10x16";
  case 300: return "Matrix10x16_paren";
  case 301: return "Matrix10x16_getVal";
  case 302: return "Matrix10x16_setVal";
  case 303: return "Matrix10x16_rows";
  case 304: return "Matrix10x16_cols";
  case 305: return "Matrix10x16_data";
  case 306: return "Matrix10x16_zero";
  case 307: return "Matrix10x16_fillRowMajorBuffer";
  case 308: return "Matrix10x16_fillColMajorBuffer";
  case 309: return "Matrix10x16_toString";
  case 310: return "Matrix10x16_display";
  case 311: return "Matrix10x16_toMatlab";
  case 312: return "Matrix10x16_fromMatlab";
  case 313: return "delete_Matrix10x16";
  case 314: return "new_Vector3";
  case 315: return "Vector3_paren";
  case 316: return "Vector3_brace";
  case 317: return "Vector3_getVal";
  case 318: return "Vector3_setVal";
  case 319: return "Vector3_cbegin";
  case 320: return "Vector3_cend";
  case 321: return "Vector3_begin";
  case 322: return "Vector3_end";
  case 323: return "Vector3_size";
  case 324: return "Vector3_data";
  case 325: return "Vector3_zero";
  case 326: return "Vector3_fillBuffer";
  case 327: return "Vector3_toString";
  case 328: return "Vector3_display";
  case 329: return "Vector3_toMatlab";
  case 330: return "Vector3_fromMatlab";
  case 331: return "delete_Vector3";
  case 332: return "new_Vector4";
  case 333: return "Vector4_paren";
  case 334: return "Vector4_brace";
  case 335: return "Vector4_getVal";
  case 336: return "Vector4_setVal";
  case 337: return "Vector4_cbegin";
  case 338: return "Vector4_cend";
  case 339: return "Vector4_begin";
  case 340: return "Vector4_end";
  case 341: return "Vector4_size";
  case 342: return "Vector4_data";
  case 343: return "Vector4_zero";
  case 344: return "Vector4_fillBuffer";
  case 345: return "Vector4_toString";
  case 346: return "Vector4_display";
  case 347: return "Vector4_toMatlab";
  case 348: return "Vector4_fromMatlab";
  case 349: return "delete_Vector4";
  case 350: return "new_Vector6";
  case 351: return "Vector6_paren";
  case 352: return "Vector6_brace";
  case 353: return "Vector6_getVal";
  case 354: return "Vector6_setVal";
  case 355: return "Vector6_cbegin";
  case 356: return "Vector6_cend";
  case 357: return "Vector6_begin";
  case 358: return "Vector6_end";
  case 359: return "Vector6_size";
  case 360: return "Vector6_data";
  case 361: return "Vector6_zero";
  case 362: return "Vector6_fillBuffer";
  case 363: return "Vector6_toString";
  case 364: return "Vector6_display";
  case 365: return "Vector6_toMatlab";
  case 366: return "Vector6_fromMatlab";
  case 367: return "delete_Vector6";
  case 368: return "new_Vector10";
  case 369: return "Vector10_paren";
  case 370: return "Vector10_brace";
  case 371: return "Vector10_getVal";
  case 372: return "Vector10_setVal";
  case 373: return "Vector10_cbegin";
  case 374: return "Vector10_cend";
  case 375: return "Vector10_begin";
  case 376: return "Vector10_end";
  case 377: return "Vector10_size";
  case 378: return "Vector10_data";
  case 379: return "Vector10_zero";
  case 380: return "Vector10_fillBuffer";
  case 381: return "Vector10_toString";
  case 382: return "Vector10_display";
  case 383: return "Vector10_toMatlab";
  case 384: return "Vector10_fromMatlab";
  case 385: return "delete_Vector10";
  case 386: return "new_Vector16";
  case 387: return "Vector16_paren";
  case 388: return "Vector16_brace";
  case 389: return "Vector16_getVal";
  case 390: return "Vector16_setVal";
  case 391: return "Vector16_cbegin";
  case 392: return "Vector16_cend";
  case 393: return "Vector16_begin";
  case 394: return "Vector16_end";
  case 395: return "Vector16_size";
  case 396: return "Vector16_data";
  case 397: return "Vector16_zero";
  case 398: return "Vector16_fillBuffer";
  case 399: return "Vector16_toString";
  case 400: return "Vector16_display";
  case 401: return "Vector16_toMatlab";
  case 402: return "Vector16_fromMatlab";
  case 403: return "delete_Vector16";
  case 404: return "new_PositionRaw";
  case 405: return "PositionRaw_changePoint";
  case 406: return "PositionRaw_changeRefPoint";
  case 407: return "PositionRaw_compose";
  case 408: return "PositionRaw_inverse";
  case 409: return "PositionRaw_changePointOf";
  case 410: return "PositionRaw_toString";
  case 411: return "PositionRaw_display";
  case 412: return "delete_PositionRaw";
  case 413: return "new_Position";
  case 414: return "Position_changePoint";
  case 415: return "Position_changeRefPoint";
  case 416: return "Position_changeCoordinateFrame";
  case 417: return "Position_compose";
  case 418: return "Position_inverse";
  case 419: return "Position_changePointOf";
  case 420: return "Position_plus";
  case 421: return "Position_minus";
  case 422: return "Position_uminus";
  case 423: return "Position_mtimes";
  case 424: return "Position_toString";
  case 425: return "Position_display";
  case 426: return "Position_Zero";
  case 427: return "delete_Position";
  case 428: return "new_GeomVector3";
  case 429: return "GeomVector3_changeCoordFrame";
  case 430: return "GeomVector3_compose";
  case 431: return "GeomVector3_inverse";
  case 432: return "GeomVector3_dot";
  case 433: return "GeomVector3_plus";
  case 434: return "GeomVector3_minus";
  case 435: return "GeomVector3_uminus";
  case 436: return "GeomVector3_exp";
  case 437: return "GeomVector3_cross";
  case 438: return "delete_GeomVector3";
  case 439: return "new_SpatialMotionVectorBase";
  case 440: return "SpatialMotionVectorBase_getLinearVec3";
  case 441: return "SpatialMotionVectorBase_getAngularVec3";
  case 442: return "SpatialMotionVectorBase_setLinearVec3";
  case 443: return "SpatialMotionVectorBase_setAngularVec3";
  case 444: return "SpatialMotionVectorBase_paren";
  case 445: return "SpatialMotionVectorBase_getVal";
  case 446: return "SpatialMotionVectorBase_setVal";
  case 447: return "SpatialMotionVectorBase_size";
  case 448: return "SpatialMotionVectorBase_zero";
  case 449: return "SpatialMotionVectorBase_changePoint";
  case 450: return "SpatialMotionVectorBase_changeCoordFrame";
  case 451: return "SpatialMotionVectorBase_compose";
  case 452: return "SpatialMotionVectorBase_inverse";
  case 453: return "SpatialMotionVectorBase_dot";
  case 454: return "SpatialMotionVectorBase_plus";
  case 455: return "SpatialMotionVectorBase_minus";
  case 456: return "SpatialMotionVectorBase_uminus";
  case 457: return "SpatialMotionVectorBase_Zero";
  case 458: return "SpatialMotionVectorBase_asVector";
  case 459: return "SpatialMotionVectorBase_toString";
  case 460: return "SpatialMotionVectorBase_display";
  case 461: return "SpatialMotionVectorBase_toMatlab";
  case 462: return "SpatialMotionVectorBase_fromMatlab";
  case 463: return "delete_SpatialMotionVectorBase";
  case 464: return "new_SpatialForceVectorBase";
  case 465: return "SpatialForceVectorBase_getLinearVec3";
  case 466: return "SpatialForceVectorBase_getAngularVec3";
  case 467: return "SpatialForceVectorBase_setLinearVec3";
  case 468: return "SpatialForceVectorBase_setAngularVec3";
  case 469: return "SpatialForceVectorBase_paren";
  case 470: return "SpatialForceVectorBase_getVal";
  case 471: return "SpatialForceVectorBase_setVal";
  case 472: return "SpatialForceVectorBase_size";
  case 473: return "SpatialForceVectorBase_zero";
  case 474: return "SpatialForceVectorBase_changePoint";
  case 475: return "SpatialForceVectorBase_changeCoordFrame";
  case 476: return "SpatialForceVectorBase_compose";
  case 477: return "SpatialForceVectorBase_inverse";
  case 478: return "SpatialForceVectorBase_dot";
  case 479: return "SpatialForceVectorBase_plus";
  case 480: return "SpatialForceVectorBase_minus";
  case 481: return "SpatialForceVectorBase_uminus";
  case 482: return "SpatialForceVectorBase_Zero";
  case 483: return "SpatialForceVectorBase_asVector";
  case 484: return "SpatialForceVectorBase_toString";
  case 485: return "SpatialForceVectorBase_display";
  case 486: return "SpatialForceVectorBase_toMatlab";
  case 487: return "SpatialForceVectorBase_fromMatlab";
  case 488: return "delete_SpatialForceVectorBase";
  case 489: return "new_Dummy";
  case 490: return "delete_Dummy";
  case 491: return "new_SpatialMotionVector";
  case 492: return "SpatialMotionVector_mtimes";
  case 493: return "SpatialMotionVector_cross";
  case 494: return "SpatialMotionVector_asCrossProductMatrix";
  case 495: return "SpatialMotionVector_asCrossProductMatrixWrench";
  case 496: return "SpatialMotionVector_exp";
  case 497: return "delete_SpatialMotionVector";
  case 498: return "new_SpatialForceVector";
  case 499: return "delete_SpatialForceVector";
  case 500: return "SpatialForceVector_mtimes";
  case 501: return "new_Twist";
  case 502: return "Twist_plus";
  case 503: return "Twist_minus";
  case 504: return "Twist_uminus";
  case 505: return "Twist_mtimes";
  case 506: return "delete_Twist";
  case 507: return "new_Wrench";
  case 508: return "Wrench_plus";
  case 509: return "Wrench_minus";
  case 510: return "Wrench_uminus";
  case 511: return "delete_Wrench";
  case 512: return "new_SpatialMomentum";
  case 513: return "SpatialMomentum_plus";
  case 514: return "SpatialMomentum_minus";
  case 515: return "SpatialMomentum_uminus";
  case 516: return "delete_SpatialMomentum";
  case 517: return "new_SpatialAcc";
  case 518: return "SpatialAcc_plus";
  case 519: return "SpatialAcc_minus";
  case 520: return "SpatialAcc_uminus";
  case 521: return "delete_SpatialAcc";
  case 522: return "new_ClassicalAcc";
  case 523: return "ClassicalAcc_changeCoordFrame";
  case 524: return "ClassicalAcc_Zero";
  case 525: return "ClassicalAcc_fromSpatial";
  case 526: return "ClassicalAcc_toSpatial";
  case 527: return "delete_ClassicalAcc";
  case 528: return "new_Direction";
  case 529: return "Direction_Normalize";
  case 530: return "Direction_isParallel";
  case 531: return "Direction_isPerpendicular";
  case 532: return "Direction_reverse";
  case 533: return "Direction_toString";
  case 534: return "Direction_display";
  case 535: return "Direction_Default";
  case 536: return "delete_Direction";
  case 537: return "new_Axis";
  case 538: return "Axis_getDirection";
  case 539: return "Axis_getOrigin";
  case 540: return "Axis_setDirection";
  case 541: return "Axis_setOrigin";
  case 542: return "Axis_getRotationTransform";
  case 543: return "Axis_getRotationTransformDerivative";
  case 544: return "Axis_getRotationTwist";
  case 545: return "Axis_getRotationSpatialAcc";
  case 546: return "Axis_getTranslationTransform";
  case 547: return "Axis_getTranslationTransformDerivative";
  case 548: return "Axis_getTranslationTwist";
  case 549: return "Axis_getTranslationSpatialAcc";
  case 550: return "Axis_isParallel";
  case 551: return "Axis_reverse";
  case 552: return "Axis_toString";
  case 553: return "Axis_display";
  case 554: return "delete_Axis";
  case 555: return "new_RotationalInertiaRaw";
  case 556: return "RotationalInertiaRaw_Zero";
  case 557: return "delete_RotationalInertiaRaw";
  case 558: return "new_SpatialInertiaRaw";
  case 559: return "SpatialInertiaRaw_fromRotationalInertiaWrtCenterOfMass";
  case 560: return "SpatialInertiaRaw_getMass";
  case 561: return "SpatialInertiaRaw_getCenterOfMass";
  case 562: return "SpatialInertiaRaw_getRotationalInertiaWrtFrameOrigin";
  case 563: return "SpatialInertiaRaw_getRotationalInertiaWrtCenterOfMass";
  case 564: return "SpatialInertiaRaw_combine";
  case 565: return "SpatialInertiaRaw_multiply";
  case 566: return "SpatialInertiaRaw_zero";
  case 567: return "delete_SpatialInertiaRaw";
  case 568: return "new_SpatialInertia";
  case 569: return "SpatialInertia_combine";
  case 570: return "SpatialInertia_asMatrix";
  case 571: return "SpatialInertia_applyInverse";
  case 572: return "SpatialInertia_getInverse";
  case 573: return "SpatialInertia_plus";
  case 574: return "SpatialInertia_mtimes";
  case 575: return "SpatialInertia_biasWrench";
  case 576: return "SpatialInertia_biasWrenchDerivative";
  case 577: return "SpatialInertia_Zero";
  case 578: return "SpatialInertia_asVector";
  case 579: return "SpatialInertia_fromVector";
  case 580: return "SpatialInertia_isPhysicallyConsistent";
  case 581: return "SpatialInertia_momentumRegressor";
  case 582: return "SpatialInertia_momentumDerivativeRegressor";
  case 583: return "SpatialInertia_momentumDerivativeSlotineLiRegressor";
  case 584: return "delete_SpatialInertia";
  case 585: return "new_ArticulatedBodyInertia";
  case 586: return "ArticulatedBodyInertia_getLinearLinearSubmatrix";
  case 587: return "ArticulatedBodyInertia_getLinearAngularSubmatrix";
  case 588: return "ArticulatedBodyInertia_getAngularAngularSubmatrix";
  case 589: return "ArticulatedBodyInertia_combine";
  case 590: return "ArticulatedBodyInertia_applyInverse";
  case 591: return "ArticulatedBodyInertia_asMatrix";
  case 592: return "ArticulatedBodyInertia_getInverse";
  case 593: return "ArticulatedBodyInertia_plus";
  case 594: return "ArticulatedBodyInertia_minus";
  case 595: return "ArticulatedBodyInertia_mtimes";
  case 596: return "ArticulatedBodyInertia_zero";
  case 597: return "ArticulatedBodyInertia_ABADyadHelper";
  case 598: return "ArticulatedBodyInertia_ABADyadHelperLin";
  case 599: return "delete_ArticulatedBodyInertia";
  case 600: return "RigidBodyInertiaNonLinearParametrization_mass_get";
  case 601: return "RigidBodyInertiaNonLinearParametrization_mass_set";
  case 602: return "RigidBodyInertiaNonLinearParametrization_com_get";
  case 603: return "RigidBodyInertiaNonLinearParametrization_com_set";
  case 604: return "RigidBodyInertiaNonLinearParametrization_link_R_centroidal_get";
  case 605: return "RigidBodyInertiaNonLinearParametrization_link_R_centroidal_set";
  case 606: return "RigidBodyInertiaNonLinearParametrization_centralSecondMomentOfMass_get";
  case 607: return "RigidBodyInertiaNonLinearParametrization_centralSecondMomentOfMass_set";
  case 608: return "RigidBodyInertiaNonLinearParametrization_getLinkCentroidalTransform";
  case 609: return "RigidBodyInertiaNonLinearParametrization_fromRigidBodyInertia";
  case 610: return "RigidBodyInertiaNonLinearParametrization_fromInertialParameters";
  case 611: return "RigidBodyInertiaNonLinearParametrization_toRigidBodyInertia";
  case 612: return "RigidBodyInertiaNonLinearParametrization_isPhysicallyConsistent";
  case 613: return "RigidBodyInertiaNonLinearParametrization_asVectorWithRotationAsVec";
  case 614: return "RigidBodyInertiaNonLinearParametrization_fromVectorWithRotationAsVec";
  case 615: return "RigidBodyInertiaNonLinearParametrization_getGradientWithRotationAsVec";
  case 616: return "new_RigidBodyInertiaNonLinearParametrization";
  case 617: return "delete_RigidBodyInertiaNonLinearParametrization";
  case 618: return "new_RotationRaw";
  case 619: return "RotationRaw_changeOrientFrame";
  case 620: return "RotationRaw_changeRefOrientFrame";
  case 621: return "RotationRaw_compose";
  case 622: return "RotationRaw_inverse2";
  case 623: return "RotationRaw_changeCoordFrameOf";
  case 624: return "RotationRaw_RotX";
  case 625: return "RotationRaw_RotY";
  case 626: return "RotationRaw_RotZ";
  case 627: return "RotationRaw_RPY";
  case 628: return "RotationRaw_Identity";
  case 629: return "RotationRaw_toString";
  case 630: return "RotationRaw_display";
  case 631: return "delete_RotationRaw";
  case 632: return "new_Rotation";
  case 633: return "Rotation_changeOrientFrame";
  case 634: return "Rotation_changeRefOrientFrame";
  case 635: return "Rotation_changeCoordinateFrame";
  case 636: return "Rotation_compose";
  case 637: return "Rotation_inverse2";
  case 638: return "Rotation_changeCoordFrameOf";
  case 639: return "Rotation_inverse";
  case 640: return "Rotation_mtimes";
  case 641: return "Rotation_log";
  case 642: return "Rotation_fromQuaternion";
  case 643: return "Rotation_getRPY";
  case 644: return "Rotation_asRPY";
  case 645: return "Rotation_getQuaternion";
  case 646: return "Rotation_asQuaternion";
  case 647: return "Rotation_RotX";
  case 648: return "Rotation_RotY";
  case 649: return "Rotation_RotZ";
  case 650: return "Rotation_RotAxis";
  case 651: return "Rotation_RotAxisDerivative";
  case 652: return "Rotation_RPY";
  case 653: return "Rotation_RPYRightTrivializedDerivative";
  case 654: return "Rotation_RPYRightTrivializedDerivativeRateOfChange";
  case 655: return "Rotation_RPYRightTrivializedDerivativeInverse";
  case 656: return "Rotation_RPYRightTrivializedDerivativeInverseRateOfChange";
  case 657: return "Rotation_QuaternionRightTrivializedDerivative";
  case 658: return "Rotation_QuaternionRightTrivializedDerivativeInverse";
  case 659: return "Rotation_Identity";
  case 660: return "Rotation_RotationFromQuaternion";
  case 661: return "Rotation_leftJacobian";
  case 662: return "Rotation_leftJacobianInverse";
  case 663: return "Rotation_toString";
  case 664: return "Rotation_display";
  case 665: return "delete_Rotation";
  case 666: return "new_Transform";
  case 667: return "Transform_fromHomogeneousTransform";
  case 668: return "Transform_getRotation";
  case 669: return "Transform_getPosition";
  case 670: return "Transform_setRotation";
  case 671: return "Transform_setPosition";
  case 672: return "Transform_compose";
  case 673: return "Transform_inverse2";
  case 674: return "Transform_inverse";
  case 675: return "Transform_mtimes";
  case 676: return "Transform_Identity";
  case 677: return "Transform_asHomogeneousTransform";
  case 678: return "Transform_asAdjointTransform";
  case 679: return "Transform_asAdjointTransformWrench";
  case 680: return "Transform_log";
  case 681: return "Transform_toString";
  case 682: return "Transform_display";
  case 683: return "delete_Transform";
  case 684: return "new_TransformDerivative";
  case 685: return "delete_TransformDerivative";
  case 686: return "TransformDerivative_getRotationDerivative";
  case 687: return "TransformDerivative_getPositionDerivative";
  case 688: return "TransformDerivative_setRotationDerivative";
  case 689: return "TransformDerivative_setPositionDerivative";
  case 690: return "TransformDerivative_Zero";
  case 691: return "TransformDerivative_asHomogeneousTransformDerivative";
  case 692: return "TransformDerivative_asAdjointTransformDerivative";
  case 693: return "TransformDerivative_asAdjointTransformWrenchDerivative";
  case 694: return "TransformDerivative_mtimes";
  case 695: return "TransformDerivative_derivativeOfInverse";
  case 696: return "TransformDerivative_transform";
  case 697: return "dynamic_extent_get";
  case 698: return "DynamicSpan_extent_get";
  case 699: return "new_DynamicSpan";
  case 700: return "delete_DynamicSpan";
  case 701: return "DynamicSpan_first";
  case 702: return "DynamicSpan_last";
  case 703: return "DynamicSpan_subspan";
  case 704: return "DynamicSpan_size";
  case 705: return "DynamicSpan_size_bytes";
  case 706: return "DynamicSpan_empty";
  case 707: return "DynamicSpan_brace";
  case 708: return "DynamicSpan_getVal";
  case 709: return "DynamicSpan_setVal";
  case 710: return "DynamicSpan_at";
  case 711: return "DynamicSpan_paren";
  case 712: return "DynamicSpan_begin";
  case 713: return "DynamicSpan_end";
  case 714: return "DynamicSpan_cbegin";
  case 715: return "DynamicSpan_cend";
  case 716: return "DynamicSpan_rbegin";
  case 717: return "DynamicSpan_rend";
  case 718: return "DynamicSpan_crbegin";
  case 719: return "DynamicSpan_crend";
  case 720: return "new_DynamicMatrixView";
  case 721: return "DynamicMatrixView_storageOrder";
  case 722: return "DynamicMatrixView_paren";
  case 723: return "DynamicMatrixView_rows";
  case 724: return "DynamicMatrixView_cols";
  case 725: return "DynamicMatrixView_block";
  case 726: return "delete_DynamicMatrixView";
  case 727: return "LINK_INVALID_INDEX_get";
  case 728: return "LINK_INVALID_INDEX_set";
  case 729: return "LINK_INVALID_NAME_get";
  case 730: return "LINK_INVALID_NAME_set";
  case 731: return "JOINT_INVALID_INDEX_get";
  case 732: return "JOINT_INVALID_INDEX_set";
  case 733: return "JOINT_INVALID_NAME_get";
  case 734: return "JOINT_INVALID_NAME_set";
  case 735: return "DOF_INVALID_INDEX_get";
  case 736: return "DOF_INVALID_INDEX_set";
  case 737: return "DOF_INVALID_NAME_get";
  case 738: return "DOF_INVALID_NAME_set";
  case 739: return "FRAME_INVALID_INDEX_get";
  case 740: return "FRAME_INVALID_INDEX_set";
  case 741: return "FRAME_INVALID_NAME_get";
  case 742: return "FRAME_INVALID_NAME_set";
  case 743: return "TRAVERSAL_INVALID_INDEX_get";
  case 744: return "TRAVERSAL_INVALID_INDEX_set";
  case 745: return "new_LinkPositions";
  case 746: return "LinkPositions_resize";
  case 747: return "LinkPositions_isConsistent";
  case 748: return "LinkPositions_getNrOfLinks";
  case 749: return "LinkPositions_paren";
  case 750: return "LinkPositions_toString";
  case 751: return "delete_LinkPositions";
  case 752: return "new_LinkWrenches";
  case 753: return "LinkWrenches_resize";
  case 754: return "LinkWrenches_isConsistent";
  case 755: return "LinkWrenches_getNrOfLinks";
  case 756: return "LinkWrenches_paren";
  case 757: return "LinkWrenches_toString";
  case 758: return "LinkWrenches_zero";
  case 759: return "delete_LinkWrenches";
  case 760: return "new_LinkInertias";
  case 761: return "LinkInertias_resize";
  case 762: return "LinkInertias_isConsistent";
  case 763: return "LinkInertias_paren";
  case 764: return "delete_LinkInertias";
  case 765: return "new_LinkArticulatedBodyInertias";
  case 766: return "LinkArticulatedBodyInertias_resize";
  case 767: return "LinkArticulatedBodyInertias_isConsistent";
  case 768: return "LinkArticulatedBodyInertias_paren";
  case 769: return "delete_LinkArticulatedBodyInertias";
  case 770: return "new_LinkVelArray";
  case 771: return "LinkVelArray_resize";
  case 772: return "LinkVelArray_isConsistent";
  case 773: return "LinkVelArray_getNrOfLinks";
  case 774: return "LinkVelArray_paren";
  case 775: return "LinkVelArray_toString";
  case 776: return "delete_LinkVelArray";
  case 777: return "new_LinkAccArray";
  case 778: return "LinkAccArray_resize";
  case 779: return "LinkAccArray_isConsistent";
  case 780: return "LinkAccArray_paren";
  case 781: return "LinkAccArray_getNrOfLinks";
  case 782: return "LinkAccArray_toString";
  case 783: return "delete_LinkAccArray";
  case 784: return "new_Link";
  case 785: return "Link_inertia";
  case 786: return "Link_setInertia";
  case 787: return "Link_getInertia";
  case 788: return "Link_setIndex";
  case 789: return "Link_getIndex";
  case 790: return "delete_Link";
  case 791: return "delete_IJoint";
  case 792: return "IJoint_clone";
  case 793: return "IJoint_getNrOfPosCoords";
  case 794: return "IJoint_getNrOfDOFs";
  case 795: return "IJoint_setAttachedLinks";
  case 796: return "IJoint_setRestTransform";
  case 797: return "IJoint_getFirstAttachedLink";
  case 798: return "IJoint_getSecondAttachedLink";
  case 799: return "IJoint_getRestTransform";
  case 800: return "IJoint_getTransform";
  case 801: return "IJoint_getTransformDerivative";
  case 802: return "IJoint_getMotionSubspaceVector";
  case 803: return "IJoint_computeChildPosVelAcc";
  case 804: return "IJoint_computeChildVelAcc";
  case 805: return "IJoint_computeChildVel";
  case 806: return "IJoint_computeChildAcc";
  case 807: return "IJoint_computeChildBiasAcc";
  case 808: return "IJoint_computeJointTorque";
  case 809: return "IJoint_setIndex";
  case 810: return "IJoint_getIndex";
  case 811: return "IJoint_setPosCoordsOffset";
  case 812: return "IJoint_getPosCoordsOffset";
  case 813: return "IJoint_setDOFsOffset";
  case 814: return "IJoint_getDOFsOffset";
  case 815: return "IJoint_hasPosLimits";
  case 816: return "IJoint_enablePosLimits";
  case 817: return "IJoint_getPosLimits";
  case 818: return "IJoint_getMinPosLimit";
  case 819: return "IJoint_getMaxPosLimit";
  case 820: return "IJoint_setPosLimits";
  case 821: return "IJoint_isRevoluteJoint";
  case 822: return "IJoint_isFixedJoint";
  case 823: return "IJoint_asRevoluteJoint";
  case 824: return "IJoint_asFixedJoint";
  case 825: return "new_FixedJoint";
  case 826: return "delete_FixedJoint";
  case 827: return "FixedJoint_clone";
  case 828: return "FixedJoint_getNrOfPosCoords";
  case 829: return "FixedJoint_getNrOfDOFs";
  case 830: return "FixedJoint_setAttachedLinks";
  case 831: return "FixedJoint_setRestTransform";
  case 832: return "FixedJoint_getFirstAttachedLink";
  case 833: return "FixedJoint_getSecondAttachedLink";
  case 834: return "FixedJoint_getRestTransform";
  case 835: return "FixedJoint_getTransform";
  case 836: return "FixedJoint_getTransformDerivative";
  case 837: return "FixedJoint_getMotionSubspaceVector";
  case 838: return "FixedJoint_computeChildPosVelAcc";
  case 839: return "FixedJoint_computeChildVelAcc";
  case 840: return "FixedJoint_computeChildVel";
  case 841: return "FixedJoint_computeChildAcc";
  case 842: return "FixedJoint_computeChildBiasAcc";
  case 843: return "FixedJoint_computeJointTorque";
  case 844: return "FixedJoint_setIndex";
  case 845: return "FixedJoint_getIndex";
  case 846: return "FixedJoint_setPosCoordsOffset";
  case 847: return "FixedJoint_getPosCoordsOffset";
  case 848: return "FixedJoint_setDOFsOffset";
  case 849: return "FixedJoint_getDOFsOffset";
  case 850: return "FixedJoint_hasPosLimits";
  case 851: return "FixedJoint_enablePosLimits";
  case 852: return "FixedJoint_getPosLimits";
  case 853: return "FixedJoint_getMinPosLimit";
  case 854: return "FixedJoint_getMaxPosLimit";
  case 855: return "FixedJoint_setPosLimits";
  case 856: return "delete_MovableJointImpl1";
  case 857: return "MovableJointImpl1_getNrOfPosCoords";
  case 858: return "MovableJointImpl1_getNrOfDOFs";
  case 859: return "MovableJointImpl1_setIndex";
  case 860: return "MovableJointImpl1_getIndex";
  case 861: return "MovableJointImpl1_setPosCoordsOffset";
  case 862: return "MovableJointImpl1_getPosCoordsOffset";
  case 863: return "MovableJointImpl1_setDOFsOffset";
  case 864: return "MovableJointImpl1_getDOFsOffset";
  case 865: return "delete_MovableJointImpl2";
  case 866: return "MovableJointImpl2_getNrOfPosCoords";
  case 867: return "MovableJointImpl2_getNrOfDOFs";
  case 868: return "MovableJointImpl2_setIndex";
  case 869: return "MovableJointImpl2_getIndex";
  case 870: return "MovableJointImpl2_setPosCoordsOffset";
  case 871: return "MovableJointImpl2_getPosCoordsOffset";
  case 872: return "MovableJointImpl2_setDOFsOffset";
  case 873: return "MovableJointImpl2_getDOFsOffset";
  case 874: return "delete_MovableJointImpl3";
  case 875: return "MovableJointImpl3_getNrOfPosCoords";
  case 876: return "MovableJointImpl3_getNrOfDOFs";
  case 877: return "MovableJointImpl3_setIndex";
  case 878: return "MovableJointImpl3_getIndex";
  case 879: return "MovableJointImpl3_setPosCoordsOffset";
  case 880: return "MovableJointImpl3_getPosCoordsOffset";
  case 881: return "MovableJointImpl3_setDOFsOffset";
  case 882: return "MovableJointImpl3_getDOFsOffset";
  case 883: return "delete_MovableJointImpl4";
  case 884: return "MovableJointImpl4_getNrOfPosCoords";
  case 885: return "MovableJointImpl4_getNrOfDOFs";
  case 886: return "MovableJointImpl4_setIndex";
  case 887: return "MovableJointImpl4_getIndex";
  case 888: return "MovableJointImpl4_setPosCoordsOffset";
  case 889: return "MovableJointImpl4_getPosCoordsOffset";
  case 890: return "MovableJointImpl4_setDOFsOffset";
  case 891: return "MovableJointImpl4_getDOFsOffset";
  case 892: return "delete_MovableJointImpl5";
  case 893: return "MovableJointImpl5_getNrOfPosCoords";
  case 894: return "MovableJointImpl5_getNrOfDOFs";
  case 895: return "MovableJointImpl5_setIndex";
  case 896: return "MovableJointImpl5_getIndex";
  case 897: return "MovableJointImpl5_setPosCoordsOffset";
  case 898: return "MovableJointImpl5_getPosCoordsOffset";
  case 899: return "MovableJointImpl5_setDOFsOffset";
  case 900: return "MovableJointImpl5_getDOFsOffset";
  case 901: return "delete_MovableJointImpl6";
  case 902: return "MovableJointImpl6_getNrOfPosCoords";
  case 903: return "MovableJointImpl6_getNrOfDOFs";
  case 904: return "MovableJointImpl6_setIndex";
  case 905: return "MovableJointImpl6_getIndex";
  case 906: return "MovableJointImpl6_setPosCoordsOffset";
  case 907: return "MovableJointImpl6_getPosCoordsOffset";
  case 908: return "MovableJointImpl6_setDOFsOffset";
  case 909: return "MovableJointImpl6_getDOFsOffset";
  case 910: return "new_RevoluteJoint";
  case 911: return "delete_RevoluteJoint";
  case 912: return "RevoluteJoint_clone";
  case 913: return "RevoluteJoint_setAttachedLinks";
  case 914: return "RevoluteJoint_setRestTransform";
  case 915: return "RevoluteJoint_setAxis";
  case 916: return "RevoluteJoint_getFirstAttachedLink";
  case 917: return "RevoluteJoint_getSecondAttachedLink";
  case 918: return "RevoluteJoint_getAxis";
  case 919: return "RevoluteJoint_getRestTransform";
  case 920: return "RevoluteJoint_getTransform";
  case 921: return "RevoluteJoint_getTransformDerivative";
  case 922: return "RevoluteJoint_getMotionSubspaceVector";
  case 923: return "RevoluteJoint_computeChildPosVelAcc";
  case 924: return "RevoluteJoint_computeChildVel";
  case 925: return "RevoluteJoint_computeChildVelAcc";
  case 926: return "RevoluteJoint_computeChildAcc";
  case 927: return "RevoluteJoint_computeChildBiasAcc";
  case 928: return "RevoluteJoint_computeJointTorque";
  case 929: return "RevoluteJoint_hasPosLimits";
  case 930: return "RevoluteJoint_enablePosLimits";
  case 931: return "RevoluteJoint_getPosLimits";
  case 932: return "RevoluteJoint_getMinPosLimit";
  case 933: return "RevoluteJoint_getMaxPosLimit";
  case 934: return "RevoluteJoint_setPosLimits";
  case 935: return "new_PrismaticJoint";
  case 936: return "delete_PrismaticJoint";
  case 937: return "PrismaticJoint_clone";
  case 938: return "PrismaticJoint_setAttachedLinks";
  case 939: return "PrismaticJoint_setRestTransform";
  case 940: return "PrismaticJoint_setAxis";
  case 941: return "PrismaticJoint_getFirstAttachedLink";
  case 942: return "PrismaticJoint_getSecondAttachedLink";
  case 943: return "PrismaticJoint_getAxis";
  case 944: return "PrismaticJoint_getRestTransform";
  case 945: return "PrismaticJoint_getTransform";
  case 946: return "PrismaticJoint_getTransformDerivative";
  case 947: return "PrismaticJoint_getMotionSubspaceVector";
  case 948: return "PrismaticJoint_computeChildPosVelAcc";
  case 949: return "PrismaticJoint_computeChildVel";
  case 950: return "PrismaticJoint_computeChildVelAcc";
  case 951: return "PrismaticJoint_computeChildAcc";
  case 952: return "PrismaticJoint_computeChildBiasAcc";
  case 953: return "PrismaticJoint_computeJointTorque";
  case 954: return "PrismaticJoint_hasPosLimits";
  case 955: return "PrismaticJoint_enablePosLimits";
  case 956: return "PrismaticJoint_getPosLimits";
  case 957: return "PrismaticJoint_getMinPosLimit";
  case 958: return "PrismaticJoint_getMaxPosLimit";
  case 959: return "PrismaticJoint_setPosLimits";
  case 960: return "new_Traversal";
  case 961: return "delete_Traversal";
  case 962: return "Traversal_getNrOfVisitedLinks";
  case 963: return "Traversal_getLink";
  case 964: return "Traversal_getBaseLink";
  case 965: return "Traversal_getParentLink";
  case 966: return "Traversal_getParentJoint";
  case 967: return "Traversal_getParentLinkFromLinkIndex";
  case 968: return "Traversal_getParentJointFromLinkIndex";
  case 969: return "Traversal_getTraversalIndexFromLinkIndex";
  case 970: return "Traversal_reset";
  case 971: return "Traversal_addTraversalBase";
  case 972: return "Traversal_addTraversalElement";
  case 973: return "Traversal_isParentOf";
  case 974: return "Traversal_getChildLinkIndexFromJointIndex";
  case 975: return "Traversal_getParentLinkIndexFromJointIndex";
  case 976: return "Traversal_toString";
  case 977: return "new_Material";
  case 978: return "Material_name";
  case 979: return "Material_hasColor";
  case 980: return "Material_color";
  case 981: return "Material_setColor";
  case 982: return "Material_hasTexture";
  case 983: return "Material_texture";
  case 984: return "Material_setTexture";
  case 985: return "delete_Material";
  case 986: return "delete_SolidShape";
  case 987: return "SolidShape_clone";
  case 988: return "SolidShape_getName";
  case 989: return "SolidShape_setName";
  case 990: return "SolidShape_isNameValid";
  case 991: return "SolidShape_getLink_H_geometry";
  case 992: return "SolidShape_setLink_H_geometry";
  case 993: return "SolidShape_isMaterialSet";
  case 994: return "SolidShape_getMaterial";
  case 995: return "SolidShape_setMaterial";
  case 996: return "SolidShape_isSphere";
  case 997: return "SolidShape_isBox";
  case 998: return "SolidShape_isCylinder";
  case 999: return "SolidShape_isExternalMesh";
  case 1000: return "SolidShape_asSphere";
  case 1001: return "SolidShape_asBox";
  case 1002: return "SolidShape_asCylinder";
  case 1003: return "SolidShape_asExternalMesh";
  case 1004: return "delete_Sphere";
  case 1005: return "Sphere_clone";
  case 1006: return "Sphere_getRadius";
  case 1007: return "Sphere_setRadius";
  case 1008: return "new_Sphere";
  case 1009: return "delete_Box";
  case 1010: return "Box_clone";
  case 1011: return "Box_getX";
  case 1012: return "Box_setX";
  case 1013: return "Box_getY";
  case 1014: return "Box_setY";
  case 1015: return "Box_getZ";
  case 1016: return "Box_setZ";
  case 1017: return "new_Box";
  case 1018: return "delete_Cylinder";
  case 1019: return "Cylinder_clone";
  case 1020: return "Cylinder_getLength";
  case 1021: return "Cylinder_setLength";
  case 1022: return "Cylinder_getRadius";
  case 1023: return "Cylinder_setRadius";
  case 1024: return "new_Cylinder";
  case 1025: return "delete_ExternalMesh";
  case 1026: return "ExternalMesh_clone";
  case 1027: return "ExternalMesh_getFilename";
  case 1028: return "ExternalMesh_getFileLocationOnLocalFileSystem";
  case 1029: return "ExternalMesh_setFilename";
  case 1030: return "ExternalMesh_getScale";
  case 1031: return "ExternalMesh_setScale";
  case 1032: return "new_ExternalMesh";
  case 1033: return "delete_ModelSolidShapes";
  case 1034: return "new_ModelSolidShapes";
  case 1035: return "ModelSolidShapes_clear";
  case 1036: return "ModelSolidShapes_resize";
  case 1037: return "ModelSolidShapes_isConsistent";
  case 1038: return "ModelSolidShapes_getLinkSolidShapes";
  case 1039: return "Neighbor_neighborLink_get";
  case 1040: return "Neighbor_neighborLink_set";
  case 1041: return "Neighbor_neighborJoint_get";
  case 1042: return "Neighbor_neighborJoint_set";
  case 1043: return "new_Neighbor";
  case 1044: return "delete_Neighbor";
  case 1045: return "new_Model";
  case 1046: return "Model_copy";
  case 1047: return "delete_Model";
  case 1048: return "Model_getNrOfLinks";
  case 1049: return "Model_getLinkName";
  case 1050: return "Model_getLinkIndex";
  case 1051: return "Model_isValidLinkIndex";
  case 1052: return "Model_getLink";
  case 1053: return "Model_addLink";
  case 1054: return "Model_getNrOfJoints";
  case 1055: return "Model_getJointName";
  case 1056: return "Model_getTotalMass";
  case 1057: return "Model_getJointIndex";
  case 1058: return "Model_getJoint";
  case 1059: return "Model_isValidJointIndex";
  case 1060: return "Model_isLinkNameUsed";
  case 1061: return "Model_isJointNameUsed";
  case 1062: return "Model_isFrameNameUsed";
  case 1063: return "Model_addJoint";
  case 1064: return "Model_addJointAndLink";
  case 1065: return "Model_insertLinkToExistingJointAndAddJointForDisplacedLink";
  case 1066: return "Model_getNrOfPosCoords";
  case 1067: return "Model_getNrOfDOFs";
  case 1068: return "Model_getNrOfFrames";
  case 1069: return "Model_addAdditionalFrameToLink";
  case 1070: return "Model_getFrameName";
  case 1071: return "Model_getFrameIndex";
  case 1072: return "Model_isValidFrameIndex";
  case 1073: return "Model_getFrameTransform";
  case 1074: return "Model_getFrameLink";
  case 1075: return "Model_getLinkAdditionalFrames";
  case 1076: return "Model_getNrOfNeighbors";
  case 1077: return "Model_getNeighbor";
  case 1078: return "Model_setDefaultBaseLink";
  case 1079: return "Model_getDefaultBaseLink";
  case 1080: return "Model_computeFullTreeTraversal";
  case 1081: return "Model_getInertialParameters";
  case 1082: return "Model_updateInertialParameters";
  case 1083: return "Model_visualSolidShapes";
  case 1084: return "Model_collisionSolidShapes";
  case 1085: return "Model_toString";
  case 1086: return "new_JointPosDoubleArray";
  case 1087: return "JointPosDoubleArray_resize";
  case 1088: return "JointPosDoubleArray_isConsistent";
  case 1089: return "delete_JointPosDoubleArray";
  case 1090: return "new_JointDOFsDoubleArray";
  case 1091: return "JointDOFsDoubleArray_resize";
  case 1092: return "JointDOFsDoubleArray_isConsistent";
  case 1093: return "delete_JointDOFsDoubleArray";
  case 1094: return "new_DOFSpatialForceArray";
  case 1095: return "DOFSpatialForceArray_resize";
  case 1096: return "DOFSpatialForceArray_isConsistent";
  case 1097: return "DOFSpatialForceArray_paren";
  case 1098: return "delete_DOFSpatialForceArray";
  case 1099: return "new_DOFSpatialMotionArray";
  case 1100: return "DOFSpatialMotionArray_resize";
  case 1101: return "DOFSpatialMotionArray_isConsistent";
  case 1102: return "DOFSpatialMotionArray_paren";
  case 1103: return "delete_DOFSpatialMotionArray";
  case 1104: return "new_FrameFreeFloatingJacobian";
  case 1105: return "FrameFreeFloatingJacobian_resize";
  case 1106: return "FrameFreeFloatingJacobian_isConsistent";
  case 1107: return "delete_FrameFreeFloatingJacobian";
  case 1108: return "new_MomentumFreeFloatingJacobian";
  case 1109: return "MomentumFreeFloatingJacobian_resize";
  case 1110: return "MomentumFreeFloatingJacobian_isConsistent";
  case 1111: return "delete_MomentumFreeFloatingJacobian";
  case 1112: return "new_FreeFloatingMassMatrix";
  case 1113: return "FreeFloatingMassMatrix_resize";
  case 1114: return "delete_FreeFloatingMassMatrix";
  case 1115: return "new_FreeFloatingPos";
  case 1116: return "FreeFloatingPos_resize";
  case 1117: return "FreeFloatingPos_worldBasePos";
  case 1118: return "FreeFloatingPos_jointPos";
  case 1119: return "FreeFloatingPos_getNrOfPosCoords";
  case 1120: return "delete_FreeFloatingPos";
  case 1121: return "new_FreeFloatingGeneralizedTorques";
  case 1122: return "FreeFloatingGeneralizedTorques_resize";
  case 1123: return "FreeFloatingGeneralizedTorques_baseWrench";
  case 1124: return "FreeFloatingGeneralizedTorques_jointTorques";
  case 1125: return "FreeFloatingGeneralizedTorques_getNrOfDOFs";
  case 1126: return "delete_FreeFloatingGeneralizedTorques";
  case 1127: return "new_FreeFloatingVel";
  case 1128: return "FreeFloatingVel_resize";
  case 1129: return "FreeFloatingVel_baseVel";
  case 1130: return "FreeFloatingVel_jointVel";
  case 1131: return "FreeFloatingVel_getNrOfDOFs";
  case 1132: return "delete_FreeFloatingVel";
  case 1133: return "new_FreeFloatingAcc";
  case 1134: return "FreeFloatingAcc_resize";
  case 1135: return "FreeFloatingAcc_baseAcc";
  case 1136: return "FreeFloatingAcc_jointAcc";
  case 1137: return "FreeFloatingAcc_getNrOfDOFs";
  case 1138: return "delete_FreeFloatingAcc";
  case 1139: return "ContactWrench_contactId";
  case 1140: return "ContactWrench_contactPoint";
  case 1141: return "ContactWrench_contactWrench";
  case 1142: return "new_ContactWrench";
  case 1143: return "delete_ContactWrench";
  case 1144: return "new_LinkContactWrenches";
  case 1145: return "LinkContactWrenches_resize";
  case 1146: return "LinkContactWrenches_getNrOfContactsForLink";
  case 1147: return "LinkContactWrenches_setNrOfContactsForLink";
  case 1148: return "LinkContactWrenches_getNrOfLinks";
  case 1149: return "LinkContactWrenches_contactWrench";
  case 1150: return "LinkContactWrenches_computeNetWrenches";
  case 1151: return "LinkContactWrenches_toString";
  case 1152: return "delete_LinkContactWrenches";
  case 1153: return "SolidShapesVector_pop";
  case 1154: return "SolidShapesVector_brace";
  case 1155: return "SolidShapesVector_setbrace";
  case 1156: return "SolidShapesVector_append";
  case 1157: return "SolidShapesVector_empty";
  case 1158: return "SolidShapesVector_size";
  case 1159: return "SolidShapesVector_swap";
  case 1160: return "SolidShapesVector_begin";
  case 1161: return "SolidShapesVector_end";
  case 1162: return "SolidShapesVector_rbegin";
  case 1163: return "SolidShapesVector_rend";
  case 1164: return "SolidShapesVector_clear";
  case 1165: return "SolidShapesVector_get_allocator";
  case 1166: return "SolidShapesVector_pop_back";
  case 1167: return "SolidShapesVector_erase";
  case 1168: return "new_SolidShapesVector";
  case 1169: return "SolidShapesVector_push_back";
  case 1170: return "SolidShapesVector_front";
  case 1171: return "SolidShapesVector_back";
  case 1172: return "SolidShapesVector_assign";
  case 1173: return "SolidShapesVector_resize";
  case 1174: return "SolidShapesVector_insert";
  case 1175: return "SolidShapesVector_reserve";
  case 1176: return "SolidShapesVector_capacity";
  case 1177: return "delete_SolidShapesVector";
  case 1178: return "LinksSolidShapesVector_pop";
  case 1179: return "LinksSolidShapesVector_brace";
  case 1180: return "LinksSolidShapesVector_setbrace";
  case 1181: return "LinksSolidShapesVector_append";
  case 1182: return "LinksSolidShapesVector_empty";
  case 1183: return "LinksSolidShapesVector_size";
  case 1184: return "LinksSolidShapesVector_swap";
  case 1185: return "LinksSolidShapesVector_begin";
  case 1186: return "LinksSolidShapesVector_end";
  case 1187: return "LinksSolidShapesVector_rbegin";
  case 1188: return "LinksSolidShapesVector_rend";
  case 1189: return "LinksSolidShapesVector_clear";
  case 1190: return "LinksSolidShapesVector_get_allocator";
  case 1191: return "LinksSolidShapesVector_pop_back";
  case 1192: return "LinksSolidShapesVector_erase";
  case 1193: return "new_LinksSolidShapesVector";
  case 1194: return "LinksSolidShapesVector_push_back";
  case 1195: return "LinksSolidShapesVector_front";
  case 1196: return "LinksSolidShapesVector_back";
  case 1197: return "LinksSolidShapesVector_assign";
  case 1198: return "LinksSolidShapesVector_resize";
  case 1199: return "LinksSolidShapesVector_insert";
  case 1200: return "LinksSolidShapesVector_reserve";
  case 1201: return "LinksSolidShapesVector_capacity";
  case 1202: return "delete_LinksSolidShapesVector";
  case 1203: return "_wrap_ForwardPositionKinematics";
  case 1204: return "_wrap_ForwardVelAccKinematics";
  case 1205: return "_wrap_ForwardPosVelAccKinematics";
  case 1206: return "_wrap_ForwardPosVelKinematics";
  case 1207: return "_wrap_ForwardAccKinematics";
  case 1208: return "_wrap_ForwardBiasAccKinematics";
  case 1209: return "_wrap_ComputeLinearAndAngularMomentum";
  case 1210: return "_wrap_ComputeLinearAndAngularMomentumDerivativeBias";
  case 1211: return "_wrap_RNEADynamicPhase";
  case 1212: return "_wrap_CompositeRigidBodyAlgorithm";
  case 1213: return "new_ArticulatedBodyAlgorithmInternalBuffers";
  case 1214: return "ArticulatedBodyAlgorithmInternalBuffers_resize";
  case 1215: return "ArticulatedBodyAlgorithmInternalBuffers_isConsistent";
  case 1216: return "ArticulatedBodyAlgorithmInternalBuffers_S_get";
  case 1217: return "ArticulatedBodyAlgorithmInternalBuffers_S_set";
  case 1218: return "ArticulatedBodyAlgorithmInternalBuffers_U_get";
  case 1219: return "ArticulatedBodyAlgorithmInternalBuffers_U_set";
  case 1220: return "ArticulatedBodyAlgorithmInternalBuffers_D_get";
  case 1221: return "ArticulatedBodyAlgorithmInternalBuffers_D_set";
  case 1222: return "ArticulatedBodyAlgorithmInternalBuffers_u_get";
  case 1223: return "ArticulatedBodyAlgorithmInternalBuffers_u_set";
  case 1224: return "ArticulatedBodyAlgorithmInternalBuffers_linksVel_get";
  case 1225: return "ArticulatedBodyAlgorithmInternalBuffers_linksVel_set";
  case 1226: return "ArticulatedBodyAlgorithmInternalBuffers_linksBiasAcceleration_get";
  case 1227: return "ArticulatedBodyAlgorithmInternalBuffers_linksBiasAcceleration_set";
  case 1228: return "ArticulatedBodyAlgorithmInternalBuffers_linksAccelerations_get";
  case 1229: return "ArticulatedBodyAlgorithmInternalBuffers_linksAccelerations_set";
  case 1230: return "ArticulatedBodyAlgorithmInternalBuffers_linkABIs_get";
  case 1231: return "ArticulatedBodyAlgorithmInternalBuffers_linkABIs_set";
  case 1232: return "ArticulatedBodyAlgorithmInternalBuffers_linksBiasWrench_get";
  case 1233: return "ArticulatedBodyAlgorithmInternalBuffers_linksBiasWrench_set";
  case 1234: return "delete_ArticulatedBodyAlgorithmInternalBuffers";
  case 1235: return "_wrap_ArticulatedBodyAlgorithm";
  case 1236: return "_wrap_InverseDynamicsInertialParametersRegressor";
  case 1237: return "NR_OF_SENSOR_TYPES_get";
  case 1238: return "_wrap_isLinkSensor";
  case 1239: return "_wrap_isJointSensor";
  case 1240: return "_wrap_getSensorTypeSize";
  case 1241: return "delete_Sensor";
  case 1242: return "Sensor_getName";
  case 1243: return "Sensor_getSensorType";
  case 1244: return "Sensor_isValid";
  case 1245: return "Sensor_setName";
  case 1246: return "Sensor_clone";
  case 1247: return "Sensor_isConsistent";
  case 1248: return "Sensor_updateIndices";
  case 1249: return "delete_JointSensor";
  case 1250: return "JointSensor_getParentJoint";
  case 1251: return "JointSensor_getParentJointIndex";
  case 1252: return "JointSensor_setParentJoint";
  case 1253: return "JointSensor_setParentJointIndex";
  case 1254: return "JointSensor_isConsistent";
  case 1255: return "delete_LinkSensor";
  case 1256: return "LinkSensor_getParentLink";
  case 1257: return "LinkSensor_getParentLinkIndex";
  case 1258: return "LinkSensor_getLinkSensorTransform";
  case 1259: return "LinkSensor_setParentLink";
  case 1260: return "LinkSensor_setParentLinkIndex";
  case 1261: return "LinkSensor_setLinkSensorTransform";
  case 1262: return "LinkSensor_isConsistent";
  case 1263: return "new_SensorsList";
  case 1264: return "delete_SensorsList";
  case 1265: return "SensorsList_addSensor";
  case 1266: return "SensorsList_setSerialization";
  case 1267: return "SensorsList_getSerialization";
  case 1268: return "SensorsList_getNrOfSensors";
  case 1269: return "SensorsList_getSensorIndex";
  case 1270: return "SensorsList_getSizeOfAllSensorsMeasurements";
  case 1271: return "SensorsList_getSensor";
  case 1272: return "SensorsList_isConsistent";
  case 1273: return "SensorsList_removeSensor";
  case 1274: return "SensorsList_removeAllSensorsOfType";
  case 1275: return "SensorsList_getSixAxisForceTorqueSensor";
  case 1276: return "SensorsList_getAccelerometerSensor";
  case 1277: return "SensorsList_getGyroscopeSensor";
  case 1278: return "SensorsList_getThreeAxisAngularAccelerometerSensor";
  case 1279: return "SensorsList_getThreeAxisForceTorqueContactSensor";
  case 1280: return "new_SensorsMeasurements";
  case 1281: return "delete_SensorsMeasurements";
  case 1282: return "SensorsMeasurements_setNrOfSensors";
  case 1283: return "SensorsMeasurements_getNrOfSensors";
  case 1284: return "SensorsMeasurements_resize";
  case 1285: return "SensorsMeasurements_toVector";
  case 1286: return "SensorsMeasurements_setMeasurement";
  case 1287: return "SensorsMeasurements_getMeasurement";
  case 1288: return "SensorsMeasurements_getSizeOfAllSensorsMeasurements";
  case 1289: return "new_SixAxisForceTorqueSensor";
  case 1290: return "delete_SixAxisForceTorqueSensor";
  case 1291: return "SixAxisForceTorqueSensor_setName";
  case 1292: return "SixAxisForceTorqueSensor_setFirstLinkSensorTransform";
  case 1293: return "SixAxisForceTorqueSensor_setSecondLinkSensorTransform";
  case 1294: return "SixAxisForceTorqueSensor_getFirstLinkIndex";
  case 1295: return "SixAxisForceTorqueSensor_getSecondLinkIndex";
  case 1296: return "SixAxisForceTorqueSensor_setFirstLinkName";
  case 1297: return "SixAxisForceTorqueSensor_setSecondLinkName";
  case 1298: return "SixAxisForceTorqueSensor_getFirstLinkName";
  case 1299: return "SixAxisForceTorqueSensor_getSecondLinkName";
  case 1300: return "SixAxisForceTorqueSensor_setParentJoint";
  case 1301: return "SixAxisForceTorqueSensor_setParentJointIndex";
  case 1302: return "SixAxisForceTorqueSensor_setAppliedWrenchLink";
  case 1303: return "SixAxisForceTorqueSensor_getName";
  case 1304: return "SixAxisForceTorqueSensor_getSensorType";
  case 1305: return "SixAxisForceTorqueSensor_getParentJoint";
  case 1306: return "SixAxisForceTorqueSensor_getParentJointIndex";
  case 1307: return "SixAxisForceTorqueSensor_isValid";
  case 1308: return "SixAxisForceTorqueSensor_clone";
  case 1309: return "SixAxisForceTorqueSensor_updateIndices";
  case 1310: return "SixAxisForceTorqueSensor_getAppliedWrenchLink";
  case 1311: return "SixAxisForceTorqueSensor_isLinkAttachedToSensor";
  case 1312: return "SixAxisForceTorqueSensor_getLinkSensorTransform";
  case 1313: return "SixAxisForceTorqueSensor_getWrenchAppliedOnLink";
  case 1314: return "SixAxisForceTorqueSensor_getWrenchAppliedOnLinkMatrix";
  case 1315: return "SixAxisForceTorqueSensor_getWrenchAppliedOnLinkInverseMatrix";
  case 1316: return "SixAxisForceTorqueSensor_predictMeasurement";
  case 1317: return "SixAxisForceTorqueSensor_toString";
  case 1318: return "new_AccelerometerSensor";
  case 1319: return "delete_AccelerometerSensor";
  case 1320: return "AccelerometerSensor_setName";
  case 1321: return "AccelerometerSensor_setLinkSensorTransform";
  case 1322: return "AccelerometerSensor_setParentLink";
  case 1323: return "AccelerometerSensor_setParentLinkIndex";
  case 1324: return "AccelerometerSensor_getName";
  case 1325: return "AccelerometerSensor_getSensorType";
  case 1326: return "AccelerometerSensor_getParentLink";
  case 1327: return "AccelerometerSensor_getParentLinkIndex";
  case 1328: return "AccelerometerSensor_getLinkSensorTransform";
  case 1329: return "AccelerometerSensor_isValid";
  case 1330: return "AccelerometerSensor_clone";
  case 1331: return "AccelerometerSensor_updateIndices";
  case 1332: return "AccelerometerSensor_predictMeasurement";
  case 1333: return "new_GyroscopeSensor";
  case 1334: return "delete_GyroscopeSensor";
  case 1335: return "GyroscopeSensor_setName";
  case 1336: return "GyroscopeSensor_setLinkSensorTransform";
  case 1337: return "GyroscopeSensor_setParentLink";
  case 1338: return "GyroscopeSensor_setParentLinkIndex";
  case 1339: return "GyroscopeSensor_getName";
  case 1340: return "GyroscopeSensor_getSensorType";
  case 1341: return "GyroscopeSensor_getParentLink";
  case 1342: return "GyroscopeSensor_getParentLinkIndex";
  case 1343: return "GyroscopeSensor_getLinkSensorTransform";
  case 1344: return "GyroscopeSensor_isValid";
  case 1345: return "GyroscopeSensor_clone";
  case 1346: return "GyroscopeSensor_updateIndices";
  case 1347: return "GyroscopeSensor_predictMeasurement";
  case 1348: return "new_ThreeAxisAngularAccelerometerSensor";
  case 1349: return "delete_ThreeAxisAngularAccelerometerSensor";
  case 1350: return "ThreeAxisAngularAccelerometerSensor_setName";
  case 1351: return "ThreeAxisAngularAccelerometerSensor_setLinkSensorTransform";
  case 1352: return "ThreeAxisAngularAccelerometerSensor_setParentLink";
  case 1353: return "ThreeAxisAngularAccelerometerSensor_setParentLinkIndex";
  case 1354: return "ThreeAxisAngularAccelerometerSensor_getName";
  case 1355: return "ThreeAxisAngularAccelerometerSensor_getSensorType";
  case 1356: return "ThreeAxisAngularAccelerometerSensor_getParentLink";
  case 1357: return "ThreeAxisAngularAccelerometerSensor_getParentLinkIndex";
  case 1358: return "ThreeAxisAngularAccelerometerSensor_getLinkSensorTransform";
  case 1359: return "ThreeAxisAngularAccelerometerSensor_isValid";
  case 1360: return "ThreeAxisAngularAccelerometerSensor_clone";
  case 1361: return "ThreeAxisAngularAccelerometerSensor_updateIndices";
  case 1362: return "ThreeAxisAngularAccelerometerSensor_predictMeasurement";
  case 1363: return "new_ThreeAxisForceTorqueContactSensor";
  case 1364: return "delete_ThreeAxisForceTorqueContactSensor";
  case 1365: return "ThreeAxisForceTorqueContactSensor_setName";
  case 1366: return "ThreeAxisForceTorqueContactSensor_setLinkSensorTransform";
  case 1367: return "ThreeAxisForceTorqueContactSensor_setParentLink";
  case 1368: return "ThreeAxisForceTorqueContactSensor_setParentLinkIndex";
  case 1369: return "ThreeAxisForceTorqueContactSensor_getName";
  case 1370: return "ThreeAxisForceTorqueContactSensor_getSensorType";
  case 1371: return "ThreeAxisForceTorqueContactSensor_getParentLink";
  case 1372: return "ThreeAxisForceTorqueContactSensor_getParentLinkIndex";
  case 1373: return "ThreeAxisForceTorqueContactSensor_getLinkSensorTransform";
  case 1374: return "ThreeAxisForceTorqueContactSensor_isValid";
  case 1375: return "ThreeAxisForceTorqueContactSensor_clone";
  case 1376: return "ThreeAxisForceTorqueContactSensor_updateIndices";
  case 1377: return "ThreeAxisForceTorqueContactSensor_setLoadCellLocations";
  case 1378: return "ThreeAxisForceTorqueContactSensor_getLoadCellLocations";
  case 1379: return "ThreeAxisForceTorqueContactSensor_computeThreeAxisForceTorqueFromLoadCellMeasurements";
  case 1380: return "ThreeAxisForceTorqueContactSensor_computeCenterOfPressureFromLoadCellMeasurements";
  case 1381: return "_wrap_predictSensorsMeasurements";
  case 1382: return "_wrap_predictSensorsMeasurementsFromRawBuffers";
  case 1383: return "_wrap_dofsListFromURDF";
  case 1384: return "_wrap_dofsListFromURDFString";
  case 1385: return "ModelParserOptions_addSensorFramesAsAdditionalFrames_get";
  case 1386: return "ModelParserOptions_addSensorFramesAsAdditionalFrames_set";
  case 1387: return "ModelParserOptions_originalFilename_get";
  case 1388: return "ModelParserOptions_originalFilename_set";
  case 1389: return "new_ModelParserOptions";
  case 1390: return "delete_ModelParserOptions";
  case 1391: return "new_ModelLoader";
  case 1392: return "delete_ModelLoader";
  case 1393: return "ModelLoader_parsingOptions";
  case 1394: return "ModelLoader_setParsingOptions";
  case 1395: return "ModelLoader_loadModelFromString";
  case 1396: return "ModelLoader_loadModelFromFile";
  case 1397: return "ModelLoader_loadReducedModelFromFullModel";
  case 1398: return "ModelLoader_loadReducedModelFromString";
  case 1399: return "ModelLoader_loadReducedModelFromFile";
  case 1400: return "ModelLoader_model";
  case 1401: return "ModelLoader_sensors";
  case 1402: return "ModelLoader_isValid";
  case 1403: return "ModelExporterOptions_baseLink_get";
  case 1404: return "ModelExporterOptions_baseLink_set";
  case 1405: return "ModelExporterOptions_exportFirstBaseLinkAdditionalFrameAsFakeURDFBase_get";
  case 1406: return "ModelExporterOptions_exportFirstBaseLinkAdditionalFrameAsFakeURDFBase_set";
  case 1407: return "ModelExporterOptions_robotExportedName_get";
  case 1408: return "ModelExporterOptions_robotExportedName_set";
  case 1409: return "new_ModelExporterOptions";
  case 1410: return "delete_ModelExporterOptions";
  case 1411: return "new_ModelExporter";
  case 1412: return "delete_ModelExporter";
  case 1413: return "ModelExporter_exportingOptions";
  case 1414: return "ModelExporter_setExportingOptions";
  case 1415: return "ModelExporter_init";
  case 1416: return "ModelExporter_model";
  case 1417: return "ModelExporter_sensors";
  case 1418: return "ModelExporter_isValid";
  case 1419: return "ModelExporter_exportModelToString";
  case 1420: return "ModelExporter_exportModelToFile";
  case 1421: return "new_ModelCalibrationHelper";
  case 1422: return "delete_ModelCalibrationHelper";
  case 1423: return "ModelCalibrationHelper_loadModelFromString";
  case 1424: return "ModelCalibrationHelper_loadModelFromFile";
  case 1425: return "ModelCalibrationHelper_updateModelInertialParametersToString";
  case 1426: return "ModelCalibrationHelper_updateModelInertialParametersToFile";
  case 1427: return "ModelCalibrationHelper_model";
  case 1428: return "ModelCalibrationHelper_sensors";
  case 1429: return "ModelCalibrationHelper_isValid";
  case 1430: return "new_UnknownWrenchContact";
  case 1431: return "UnknownWrenchContact_unknownType_get";
  case 1432: return "UnknownWrenchContact_unknownType_set";
  case 1433: return "UnknownWrenchContact_contactPoint_get";
  case 1434: return "UnknownWrenchContact_contactPoint_set";
  case 1435: return "UnknownWrenchContact_forceDirection_get";
  case 1436: return "UnknownWrenchContact_forceDirection_set";
  case 1437: return "UnknownWrenchContact_knownWrench_get";
  case 1438: return "UnknownWrenchContact_knownWrench_set";
  case 1439: return "UnknownWrenchContact_contactId_get";
  case 1440: return "UnknownWrenchContact_contactId_set";
  case 1441: return "delete_UnknownWrenchContact";
  case 1442: return "new_LinkUnknownWrenchContacts";
  case 1443: return "LinkUnknownWrenchContacts_clear";
  case 1444: return "LinkUnknownWrenchContacts_resize";
  case 1445: return "LinkUnknownWrenchContacts_getNrOfContactsForLink";
  case 1446: return "LinkUnknownWrenchContacts_setNrOfContactsForLink";
  case 1447: return "LinkUnknownWrenchContacts_addNewContactForLink";
  case 1448: return "LinkUnknownWrenchContacts_addNewContactInFrame";
  case 1449: return "LinkUnknownWrenchContacts_addNewUnknownFullWrenchInFrameOrigin";
  case 1450: return "LinkUnknownWrenchContacts_contactWrench";
  case 1451: return "LinkUnknownWrenchContacts_toString";
  case 1452: return "delete_LinkUnknownWrenchContacts";
  case 1453: return "new_estimateExternalWrenchesBuffers";
  case 1454: return "estimateExternalWrenchesBuffers_resize";
  case 1455: return "estimateExternalWrenchesBuffers_getNrOfSubModels";
  case 1456: return "estimateExternalWrenchesBuffers_getNrOfLinks";
  case 1457: return "estimateExternalWrenchesBuffers_isConsistent";
  case 1458: return "estimateExternalWrenchesBuffers_A_get";
  case 1459: return "estimateExternalWrenchesBuffers_A_set";
  case 1460: return "estimateExternalWrenchesBuffers_x_get";
  case 1461: return "estimateExternalWrenchesBuffers_x_set";
  case 1462: return "estimateExternalWrenchesBuffers_b_get";
  case 1463: return "estimateExternalWrenchesBuffers_b_set";
  case 1464: return "estimateExternalWrenchesBuffers_pinvA_get";
  case 1465: return "estimateExternalWrenchesBuffers_pinvA_set";
  case 1466: return "estimateExternalWrenchesBuffers_b_contacts_subtree_get";
  case 1467: return "estimateExternalWrenchesBuffers_b_contacts_subtree_set";
  case 1468: return "estimateExternalWrenchesBuffers_subModelBase_H_link_get";
  case 1469: return "estimateExternalWrenchesBuffers_subModelBase_H_link_set";
  case 1470: return "delete_estimateExternalWrenchesBuffers";
  case 1471: return "_wrap_estimateExternalWrenchesWithoutInternalFT";
  case 1472: return "_wrap_estimateExternalWrenches";
  case 1473: return "_wrap_dynamicsEstimationForwardVelAccKinematics";
  case 1474: return "_wrap_dynamicsEstimationForwardVelKinematics";
  case 1475: return "_wrap_computeLinkNetWrenchesWithoutGravity";
  case 1476: return "_wrap_estimateLinkContactWrenchesFromLinkNetExternalWrenches";
  case 1477: return "new_ExtWrenchesAndJointTorquesEstimator";
  case 1478: return "delete_ExtWrenchesAndJointTorquesEstimator";
  case 1479: return "ExtWrenchesAndJointTorquesEstimator_setModelAndSensors";
  case 1480: return "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile";
  case 1481: return "ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs";
  case 1482: return "ExtWrenchesAndJointTorquesEstimator_model";
  case 1483: return "ExtWrenchesAndJointTorquesEstimator_sensors";
  case 1484: return "ExtWrenchesAndJointTorquesEstimator_submodels";
  case 1485: return "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase";
  case 1486: return "ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFixedBase";
  case 1487: return "ExtWrenchesAndJointTorquesEstimator_computeExpectedFTSensorsMeasurements";
  case 1488: return "ExtWrenchesAndJointTorquesEstimator_estimateExtWrenchesAndJointTorques";
  case 1489: return "ExtWrenchesAndJointTorquesEstimator_checkThatTheModelIsStill";
  case 1490: return "ExtWrenchesAndJointTorquesEstimator_estimateLinkNetWrenchesWithoutGravity";
  case 1491: return "new_SimpleLeggedOdometry";
  case 1492: return "delete_SimpleLeggedOdometry";
  case 1493: return "SimpleLeggedOdometry_setModel";
  case 1494: return "SimpleLeggedOdometry_model";
  case 1495: return "SimpleLeggedOdometry_updateKinematics";
  case 1496: return "SimpleLeggedOdometry_init";
  case 1497: return "SimpleLeggedOdometry_changeFixedFrame";
  case 1498: return "SimpleLeggedOdometry_getCurrentFixedLink";
  case 1499: return "SimpleLeggedOdometry_getWorldLinkTransform";
  case 1500: return "SimpleLeggedOdometry_getWorldFrameTransform";
  case 1501: return "_wrap_isLinkBerdyDynamicVariable";
  case 1502: return "_wrap_isJointBerdyDynamicVariable";
  case 1503: return "_wrap_isDOFBerdyDynamicVariable";
  case 1504: return "new_BerdyOptions";
  case 1505: return "BerdyOptions_berdyVariant_get";
  case 1506: return "BerdyOptions_berdyVariant_set";
  case 1507: return "BerdyOptions_includeAllNetExternalWrenchesAsDynamicVariables_get";
  case 1508: return "BerdyOptions_includeAllNetExternalWrenchesAsDynamicVariables_set";
  case 1509: return "BerdyOptions_includeAllJointAccelerationsAsSensors_get";
  case 1510: return "BerdyOptions_includeAllJointAccelerationsAsSensors_set";
  case 1511: return "BerdyOptions_includeAllJointTorquesAsSensors_get";
  case 1512: return "BerdyOptions_includeAllJointTorquesAsSensors_set";
  case 1513: return "BerdyOptions_includeAllNetExternalWrenchesAsSensors_get";
  case 1514: return "BerdyOptions_includeAllNetExternalWrenchesAsSensors_set";
  case 1515: return "BerdyOptions_includeFixedBaseExternalWrench_get";
  case 1516: return "BerdyOptions_includeFixedBaseExternalWrench_set";
  case 1517: return "BerdyOptions_jointOnWhichTheInternalWrenchIsMeasured_get";
  case 1518: return "BerdyOptions_jointOnWhichTheInternalWrenchIsMeasured_set";
  case 1519: return "BerdyOptions_baseLink_get";
  case 1520: return "BerdyOptions_baseLink_set";
  case 1521: return "BerdyOptions_checkConsistency";
  case 1522: return "delete_BerdyOptions";
  case 1523: return "BerdySensor_type_get";
  case 1524: return "BerdySensor_type_set";
  case 1525: return "BerdySensor_id_get";
  case 1526: return "BerdySensor_id_set";
  case 1527: return "BerdySensor_range_get";
  case 1528: return "BerdySensor_range_set";
  case 1529: return "BerdySensor_eq";
  case 1530: return "BerdySensor_lt";
  case 1531: return "new_BerdySensor";
  case 1532: return "delete_BerdySensor";
  case 1533: return "BerdyDynamicVariable_type_get";
  case 1534: return "BerdyDynamicVariable_type_set";
  case 1535: return "BerdyDynamicVariable_id_get";
  case 1536: return "BerdyDynamicVariable_id_set";
  case 1537: return "BerdyDynamicVariable_range_get";
  case 1538: return "BerdyDynamicVariable_range_set";
  case 1539: return "BerdyDynamicVariable_eq";
  case 1540: return "BerdyDynamicVariable_lt";
  case 1541: return "new_BerdyDynamicVariable";
  case 1542: return "delete_BerdyDynamicVariable";
  case 1543: return "new_BerdyHelper";
  case 1544: return "BerdyHelper_dynamicTraversal";
  case 1545: return "BerdyHelper_model";
  case 1546: return "BerdyHelper_sensors";
  case 1547: return "BerdyHelper_isValid";
  case 1548: return "BerdyHelper_init";
  case 1549: return "BerdyHelper_getOptions";
  case 1550: return "BerdyHelper_getNrOfDynamicVariables";
  case 1551: return "BerdyHelper_getNrOfDynamicEquations";
  case 1552: return "BerdyHelper_getNrOfSensorsMeasurements";
  case 1553: return "BerdyHelper_resizeAndZeroBerdyMatrices";
  case 1554: return "BerdyHelper_getBerdyMatrices";
  case 1555: return "BerdyHelper_getSensorsOrdering";
  case 1556: return "BerdyHelper_getRangeSensorVariable";
  case 1557: return "BerdyHelper_getRangeDOFSensorVariable";
  case 1558: return "BerdyHelper_getRangeJointSensorVariable";
  case 1559: return "BerdyHelper_getRangeLinkSensorVariable";
  case 1560: return "BerdyHelper_getRangeLinkVariable";
  case 1561: return "BerdyHelper_getRangeJointVariable";
  case 1562: return "BerdyHelper_getRangeDOFVariable";
  case 1563: return "BerdyHelper_getDynamicVariablesOrdering";
  case 1564: return "BerdyHelper_serializeDynamicVariables";
  case 1565: return "BerdyHelper_serializeSensorVariables";
  case 1566: return "BerdyHelper_serializeDynamicVariablesComputedFromFixedBaseRNEA";
  case 1567: return "BerdyHelper_extractJointTorquesFromDynamicVariables";
  case 1568: return "BerdyHelper_extractLinkNetExternalWrenchesFromDynamicVariables";
  case 1569: return "BerdyHelper_updateKinematicsFromFloatingBase";
  case 1570: return "BerdyHelper_updateKinematicsFromFixedBase";
  case 1571: return "BerdyHelper_updateKinematicsFromTraversalFixedBase";
  case 1572: return "BerdyHelper_setNetExternalWrenchMeasurementFrame";
  case 1573: return "BerdyHelper_getNetExternalWrenchMeasurementFrame";
  case 1574: return "delete_BerdyHelper";
  case 1575: return "new_BerdySparseMAPSolver";
  case 1576: return "delete_BerdySparseMAPSolver";
  case 1577: return "BerdySparseMAPSolver_setDynamicsConstraintsPriorCovariance";
  case 1578: return "BerdySparseMAPSolver_setDynamicsRegularizationPriorCovariance";
  case 1579: return "BerdySparseMAPSolver_setDynamicsRegularizationPriorExpectedValue";
  case 1580: return "BerdySparseMAPSolver_setMeasurementsPriorCovariance";
  case 1581: return "BerdySparseMAPSolver_dynamicsConstraintsPriorCovarianceInverse";
  case 1582: return "BerdySparseMAPSolver_dynamicsRegularizationPriorCovarianceInverse";
  case 1583: return "BerdySparseMAPSolver_dynamicsRegularizationPriorExpectedValue";
  case 1584: return "BerdySparseMAPSolver_measurementsPriorCovarianceInverse";
  case 1585: return "BerdySparseMAPSolver_isValid";
  case 1586: return "BerdySparseMAPSolver_initialize";
  case 1587: return "BerdySparseMAPSolver_updateEstimateInformationFixedBase";
  case 1588: return "BerdySparseMAPSolver_updateEstimateInformationFloatingBase";
  case 1589: return "BerdySparseMAPSolver_doEstimate";
  case 1590: return "BerdySparseMAPSolver_getLastEstimate";
  case 1591: return "AttitudeEstimatorState_m_orientation_get";
  case 1592: return "AttitudeEstimatorState_m_orientation_set";
  case 1593: return "AttitudeEstimatorState_m_angular_velocity_get";
  case 1594: return "AttitudeEstimatorState_m_angular_velocity_set";
  case 1595: return "AttitudeEstimatorState_m_gyroscope_bias_get";
  case 1596: return "AttitudeEstimatorState_m_gyroscope_bias_set";
  case 1597: return "new_AttitudeEstimatorState";
  case 1598: return "delete_AttitudeEstimatorState";
  case 1599: return "delete_IAttitudeEstimator";
  case 1600: return "IAttitudeEstimator_updateFilterWithMeasurements";
  case 1601: return "IAttitudeEstimator_propagateStates";
  case 1602: return "IAttitudeEstimator_getOrientationEstimateAsRotationMatrix";
  case 1603: return "IAttitudeEstimator_getOrientationEstimateAsQuaternion";
  case 1604: return "IAttitudeEstimator_getOrientationEstimateAsRPY";
  case 1605: return "IAttitudeEstimator_getInternalStateSize";
  case 1606: return "IAttitudeEstimator_getInternalState";
  case 1607: return "IAttitudeEstimator_getDefaultInternalInitialState";
  case 1608: return "IAttitudeEstimator_setInternalState";
  case 1609: return "IAttitudeEstimator_setInternalStateInitialOrientation";
  case 1610: return "AttitudeMahonyFilterParameters_time_step_in_seconds_get";
  case 1611: return "AttitudeMahonyFilterParameters_time_step_in_seconds_set";
  case 1612: return "AttitudeMahonyFilterParameters_kp_get";
  case 1613: return "AttitudeMahonyFilterParameters_kp_set";
  case 1614: return "AttitudeMahonyFilterParameters_ki_get";
  case 1615: return "AttitudeMahonyFilterParameters_ki_set";
  case 1616: return "AttitudeMahonyFilterParameters_use_magnetometer_measurements_get";
  case 1617: return "AttitudeMahonyFilterParameters_use_magnetometer_measurements_set";
  case 1618: return "AttitudeMahonyFilterParameters_confidence_magnetometer_measurements_get";
  case 1619: return "AttitudeMahonyFilterParameters_confidence_magnetometer_measurements_set";
  case 1620: return "new_AttitudeMahonyFilterParameters";
  case 1621: return "delete_AttitudeMahonyFilterParameters";
  case 1622: return "new_AttitudeMahonyFilter";
  case 1623: return "AttitudeMahonyFilter_useMagnetoMeterMeasurements";
  case 1624: return "AttitudeMahonyFilter_setConfidenceForMagnetometerMeasurements";
  case 1625: return "AttitudeMahonyFilter_setGainkp";
  case 1626: return "AttitudeMahonyFilter_setGainki";
  case 1627: return "AttitudeMahonyFilter_setTimeStepInSeconds";
  case 1628: return "AttitudeMahonyFilter_setGravityDirection";
  case 1629: return "AttitudeMahonyFilter_setParameters";
  case 1630: return "AttitudeMahonyFilter_getParameters";
  case 1631: return "AttitudeMahonyFilter_updateFilterWithMeasurements";
  case 1632: return "AttitudeMahonyFilter_propagateStates";
  case 1633: return "AttitudeMahonyFilter_getOrientationEstimateAsRotationMatrix";
  case 1634: return "AttitudeMahonyFilter_getOrientationEstimateAsQuaternion";
  case 1635: return "AttitudeMahonyFilter_getOrientationEstimateAsRPY";
  case 1636: return "AttitudeMahonyFilter_getInternalStateSize";
  case 1637: return "AttitudeMahonyFilter_getInternalState";
  case 1638: return "AttitudeMahonyFilter_getDefaultInternalInitialState";
  case 1639: return "AttitudeMahonyFilter_setInternalState";
  case 1640: return "AttitudeMahonyFilter_setInternalStateInitialOrientation";
  case 1641: return "delete_AttitudeMahonyFilter";
  case 1642: return "DiscreteExtendedKalmanFilterHelper_ekf_f";
  case 1643: return "DiscreteExtendedKalmanFilterHelper_ekf_h";
  case 1644: return "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF";
  case 1645: return "DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianH";
  case 1646: return "DiscreteExtendedKalmanFilterHelper_ekfPredict";
  case 1647: return "DiscreteExtendedKalmanFilterHelper_ekfUpdate";
  case 1648: return "DiscreteExtendedKalmanFilterHelper_ekfInit";
  case 1649: return "DiscreteExtendedKalmanFilterHelper_ekfReset";
  case 1650: return "DiscreteExtendedKalmanFilterHelper_ekfSetMeasurementVector";
  case 1651: return "DiscreteExtendedKalmanFilterHelper_ekfSetInputVector";
  case 1652: return "DiscreteExtendedKalmanFilterHelper_ekfSetInitialState";
  case 1653: return "DiscreteExtendedKalmanFilterHelper_ekfSetStateCovariance";
  case 1654: return "DiscreteExtendedKalmanFilterHelper_ekfSetSystemNoiseCovariance";
  case 1655: return "DiscreteExtendedKalmanFilterHelper_ekfSetMeasurementNoiseCovariance";
  case 1656: return "DiscreteExtendedKalmanFilterHelper_ekfSetStateSize";
  case 1657: return "DiscreteExtendedKalmanFilterHelper_ekfSetInputSize";
  case 1658: return "DiscreteExtendedKalmanFilterHelper_ekfSetOutputSize";
  case 1659: return "DiscreteExtendedKalmanFilterHelper_ekfGetStates";
  case 1660: return "DiscreteExtendedKalmanFilterHelper_ekfGetStateCovariance";
  case 1661: return "delete_DiscreteExtendedKalmanFilterHelper";
  case 1662: return "output_dimensions_with_magnetometer_get";
  case 1663: return "output_dimensions_without_magnetometer_get";
  case 1664: return "input_dimensions_get";
  case 1665: return "AttitudeQuaternionEKFParameters_time_step_in_seconds_get";
  case 1666: return "AttitudeQuaternionEKFParameters_time_step_in_seconds_set";
  case 1667: return "AttitudeQuaternionEKFParameters_bias_correlation_time_factor_get";
  case 1668: return "AttitudeQuaternionEKFParameters_bias_correlation_time_factor_set";
  case 1669: return "AttitudeQuaternionEKFParameters_accelerometer_noise_variance_get";
  case 1670: return "AttitudeQuaternionEKFParameters_accelerometer_noise_variance_set";
  case 1671: return "AttitudeQuaternionEKFParameters_magnetometer_noise_variance_get";
  case 1672: return "AttitudeQuaternionEKFParameters_magnetometer_noise_variance_set";
  case 1673: return "AttitudeQuaternionEKFParameters_gyroscope_noise_variance_get";
  case 1674: return "AttitudeQuaternionEKFParameters_gyroscope_noise_variance_set";
  case 1675: return "AttitudeQuaternionEKFParameters_gyro_bias_noise_variance_get";
  case 1676: return "AttitudeQuaternionEKFParameters_gyro_bias_noise_variance_set";
  case 1677: return "AttitudeQuaternionEKFParameters_initial_orientation_error_variance_get";
  case 1678: return "AttitudeQuaternionEKFParameters_initial_orientation_error_variance_set";
  case 1679: return "AttitudeQuaternionEKFParameters_initial_ang_vel_error_variance_get";
  case 1680: return "AttitudeQuaternionEKFParameters_initial_ang_vel_error_variance_set";
  case 1681: return "AttitudeQuaternionEKFParameters_initial_gyro_bias_error_variance_get";
  case 1682: return "AttitudeQuaternionEKFParameters_initial_gyro_bias_error_variance_set";
  case 1683: return "AttitudeQuaternionEKFParameters_use_magnetometer_measurements_get";
  case 1684: return "AttitudeQuaternionEKFParameters_use_magnetometer_measurements_set";
  case 1685: return "new_AttitudeQuaternionEKFParameters";
  case 1686: return "delete_AttitudeQuaternionEKFParameters";
  case 1687: return "new_AttitudeQuaternionEKF";
  case 1688: return "AttitudeQuaternionEKF_getParameters";
  case 1689: return "AttitudeQuaternionEKF_setParameters";
  case 1690: return "AttitudeQuaternionEKF_setGravityDirection";
  case 1691: return "AttitudeQuaternionEKF_setTimeStepInSeconds";
  case 1692: return "AttitudeQuaternionEKF_setBiasCorrelationTimeFactor";
  case 1693: return "AttitudeQuaternionEKF_useMagnetometerMeasurements";
  case 1694: return "AttitudeQuaternionEKF_setMeasurementNoiseVariance";
  case 1695: return "AttitudeQuaternionEKF_setSystemNoiseVariance";
  case 1696: return "AttitudeQuaternionEKF_setInitialStateCovariance";
  case 1697: return "AttitudeQuaternionEKF_initializeFilter";
  case 1698: return "AttitudeQuaternionEKF_updateFilterWithMeasurements";
  case 1699: return "AttitudeQuaternionEKF_propagateStates";
  case 1700: return "AttitudeQuaternionEKF_getOrientationEstimateAsRotationMatrix";
  case 1701: return "AttitudeQuaternionEKF_getOrientationEstimateAsQuaternion";
  case 1702: return "AttitudeQuaternionEKF_getOrientationEstimateAsRPY";
  case 1703: return "AttitudeQuaternionEKF_getInternalStateSize";
  case 1704: return "AttitudeQuaternionEKF_getInternalState";
  case 1705: return "AttitudeQuaternionEKF_getDefaultInternalInitialState";
  case 1706: return "AttitudeQuaternionEKF_setInternalState";
  case 1707: return "AttitudeQuaternionEKF_setInternalStateInitialOrientation";
  case 1708: return "delete_AttitudeQuaternionEKF";
  case 1709: return "_wrap_estimateInertialParametersFromLinkBoundingBoxesAndTotalMass";
  case 1710: return "_wrap_computeBoundingBoxFromShape";
  case 1711: return "_wrap_computeBoxVertices";
  case 1712: return "new_KinDynComputations";
  case 1713: return "delete_KinDynComputations";
  case 1714: return "KinDynComputations_loadRobotModel";
  case 1715: return "KinDynComputations_isValid";
  case 1716: return "KinDynComputations_setFrameVelocityRepresentation";
  case 1717: return "KinDynComputations_getFrameVelocityRepresentation";
  case 1718: return "KinDynComputations_getNrOfDegreesOfFreedom";
  case 1719: return "KinDynComputations_getDescriptionOfDegreeOfFreedom";
  case 1720: return "KinDynComputations_getDescriptionOfDegreesOfFreedom";
  case 1721: return "KinDynComputations_getNrOfLinks";
  case 1722: return "KinDynComputations_getNrOfFrames";
  case 1723: return "KinDynComputations_getFloatingBase";
  case 1724: return "KinDynComputations_setFloatingBase";
  case 1725: return "KinDynComputations_model";
  case 1726: return "KinDynComputations_getRobotModel";
  case 1727: return "KinDynComputations_getRelativeJacobianSparsityPattern";
  case 1728: return "KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern";
  case 1729: return "KinDynComputations_setJointPos";
  case 1730: return "KinDynComputations_setRobotState";
  case 1731: return "KinDynComputations_getRobotState";
  case 1732: return "KinDynComputations_getWorldBaseTransform";
  case 1733: return "KinDynComputations_getBaseTwist";
  case 1734: return "KinDynComputations_getJointPos";
  case 1735: return "KinDynComputations_getJointVel";
  case 1736: return "KinDynComputations_getModelVel";
  case 1737: return "KinDynComputations_getFrameIndex";
  case 1738: return "KinDynComputations_getFrameName";
  case 1739: return "KinDynComputations_getWorldTransform";
  case 1740: return "KinDynComputations_getWorldTransformsAsHomogeneous";
  case 1741: return "KinDynComputations_getRelativeTransformExplicit";
  case 1742: return "KinDynComputations_getRelativeTransform";
  case 1743: return "KinDynComputations_getFrameVel";
  case 1744: return "KinDynComputations_getFrameAcc";
  case 1745: return "KinDynComputations_getFrameFreeFloatingJacobian";
  case 1746: return "KinDynComputations_getRelativeJacobian";
  case 1747: return "KinDynComputations_getRelativeJacobianExplicit";
  case 1748: return "KinDynComputations_getFrameBiasAcc";
  case 1749: return "KinDynComputations_getCenterOfMassPosition";
  case 1750: return "KinDynComputations_getCenterOfMassVelocity";
  case 1751: return "KinDynComputations_getCenterOfMassJacobian";
  case 1752: return "KinDynComputations_getCenterOfMassBiasAcc";
  case 1753: return "KinDynComputations_getAverageVelocity";
  case 1754: return "KinDynComputations_getAverageVelocityJacobian";
  case 1755: return "KinDynComputations_getCentroidalAverageVelocity";
  case 1756: return "KinDynComputations_getCentroidalAverageVelocityJacobian";
  case 1757: return "KinDynComputations_getLinearAngularMomentum";
  case 1758: return "KinDynComputations_getLinearAngularMomentumJacobian";
  case 1759: return "KinDynComputations_getCentroidalTotalMomentum";
  case 1760: return "KinDynComputations_getCentroidalTotalMomentumJacobian";
  case 1761: return "KinDynComputations_getFreeFloatingMassMatrix";
  case 1762: return "KinDynComputations_inverseDynamics";
  case 1763: return "KinDynComputations_generalizedBiasForces";
  case 1764: return "KinDynComputations_generalizedGravityForces";
  case 1765: return "KinDynComputations_generalizedExternalForces";
  case 1766: return "KinDynComputations_inverseDynamicsInertialParametersRegressor";
  case 1767: return "Matrix4x4Vector_pop";
  case 1768: return "Matrix4x4Vector_brace";
  case 1769: return "Matrix4x4Vector_setbrace";
  case 1770: return "Matrix4x4Vector_append";
  case 1771: return "Matrix4x4Vector_empty";
  case 1772: return "Matrix4x4Vector_size";
  case 1773: return "Matrix4x4Vector_swap";
  case 1774: return "Matrix4x4Vector_begin";
  case 1775: return "Matrix4x4Vector_end";
  case 1776: return "Matrix4x4Vector_rbegin";
  case 1777: return "Matrix4x4Vector_rend";
  case 1778: return "Matrix4x4Vector_clear";
  case 1779: return "Matrix4x4Vector_get_allocator";
  case 1780: return "Matrix4x4Vector_pop_back";
  case 1781: return "Matrix4x4Vector_erase";
  case 1782: return "new_Matrix4x4Vector";
  case 1783: return "Matrix4x4Vector_push_back";
  case 1784: return "Matrix4x4Vector_front";
  case 1785: return "Matrix4x4Vector_back";
  case 1786: return "Matrix4x4Vector_assign";
  case 1787: return "Matrix4x4Vector_resize";
  case 1788: return "Matrix4x4Vector_insert";
  case 1789: return "Matrix4x4Vector_reserve";
  case 1790: return "Matrix4x4Vector_capacity";
  case 1791: return "Matrix4x4Vector_toMatlab";
  case 1792: return "delete_Matrix4x4Vector";
  case 1793: return "ICameraAnimator_enableMouseControl";
  case 1794: return "ICameraAnimator_getMoveSpeed";
  case 1795: return "ICameraAnimator_setMoveSpeed";
  case 1796: return "ICameraAnimator_getRotateSpeed";
  case 1797: return "ICameraAnimator_setRotateSpeed";
  case 1798: return "ICameraAnimator_getZoomSpeed";
  case 1799: return "ICameraAnimator_setZoomSpeed";
  case 1800: return "delete_ICameraAnimator";
  case 1801: return "delete_ICamera";
  case 1802: return "ICamera_setPosition";
  case 1803: return "ICamera_setTarget";
  case 1804: return "ICamera_getPosition";
  case 1805: return "ICamera_getTarget";
  case 1806: return "ICamera_setUpVector";
  case 1807: return "ICamera_animator";
  case 1808: return "ColorViz_r_get";
  case 1809: return "ColorViz_r_set";
  case 1810: return "ColorViz_g_get";
  case 1811: return "ColorViz_g_set";
  case 1812: return "ColorViz_b_get";
  case 1813: return "ColorViz_b_set";
  case 1814: return "ColorViz_a_get";
  case 1815: return "ColorViz_a_set";
  case 1816: return "new_ColorViz";
  case 1817: return "delete_ColorViz";
  case 1818: return "PixelViz_width_get";
  case 1819: return "PixelViz_width_set";
  case 1820: return "PixelViz_height_get";
  case 1821: return "PixelViz_height_set";
  case 1822: return "new_PixelViz";
  case 1823: return "delete_PixelViz";
  case 1824: return "delete_ILight";
  case 1825: return "ILight_getName";
  case 1826: return "ILight_setType";
  case 1827: return "ILight_getType";
  case 1828: return "ILight_setPosition";
  case 1829: return "ILight_getPosition";
  case 1830: return "ILight_setDirection";
  case 1831: return "ILight_getDirection";
  case 1832: return "ILight_setAmbientColor";
  case 1833: return "ILight_getAmbientColor";
  case 1834: return "ILight_setSpecularColor";
  case 1835: return "ILight_getSpecularColor";
  case 1836: return "ILight_setDiffuseColor";
  case 1837: return "ILight_getDiffuseColor";
  case 1838: return "delete_IEnvironment";
  case 1839: return "IEnvironment_getElements";
  case 1840: return "IEnvironment_setElementVisibility";
  case 1841: return "IEnvironment_setBackgroundColor";
  case 1842: return "IEnvironment_setFloorGridColor";
  case 1843: return "IEnvironment_setAmbientLight";
  case 1844: return "IEnvironment_getLights";
  case 1845: return "IEnvironment_addLight";
  case 1846: return "IEnvironment_lightViz";
  case 1847: return "IEnvironment_removeLight";
  case 1848: return "delete_IJetsVisualization";
  case 1849: return "IJetsVisualization_setJetsFrames";
  case 1850: return "IJetsVisualization_getNrOfJets";
  case 1851: return "IJetsVisualization_getJetDirection";
  case 1852: return "IJetsVisualization_setJetDirection";
  case 1853: return "IJetsVisualization_setJetColor";
  case 1854: return "IJetsVisualization_setJetsDimensions";
  case 1855: return "IJetsVisualization_setJetsIntensity";
  case 1856: return "delete_IVectorsVisualization";
  case 1857: return "IVectorsVisualization_addVector";
  case 1858: return "IVectorsVisualization_getNrOfVectors";
  case 1859: return "IVectorsVisualization_getVector";
  case 1860: return "IVectorsVisualization_updateVector";
  case 1861: return "IVectorsVisualization_setVectorColor";
  case 1862: return "IVectorsVisualization_setVectorsAspect";
  case 1863: return "delete_IFrameVisualization";
  case 1864: return "IFrameVisualization_addFrame";
  case 1865: return "IFrameVisualization_setVisible";
  case 1866: return "IFrameVisualization_getNrOfFrames";
  case 1867: return "IFrameVisualization_getFrameTransform";
  case 1868: return "IFrameVisualization_updateFrame";
  case 1869: return "delete_IModelVisualization";
  case 1870: return "IModelVisualization_setPositions";
  case 1871: return "IModelVisualization_setLinkPositions";
  case 1872: return "IModelVisualization_model";
  case 1873: return "IModelVisualization_getInstanceName";
  case 1874: return "IModelVisualization_setModelVisibility";
  case 1875: return "IModelVisualization_setModelColor";
  case 1876: return "IModelVisualization_resetModelColor";
  case 1877: return "IModelVisualization_setLinkColor";
  case 1878: return "IModelVisualization_resetLinkColor";
  case 1879: return "IModelVisualization_getLinkNames";
  case 1880: return "IModelVisualization_setLinkVisibility";
  case 1881: return "IModelVisualization_getFeatures";
  case 1882: return "IModelVisualization_setFeatureVisibility";
  case 1883: return "IModelVisualization_jets";
  case 1884: return "IModelVisualization_getWorldModelTransform";
  case 1885: return "IModelVisualization_getWorldLinkTransform";
  case 1886: return "delete_ITexture";
  case 1887: return "ITexture_environment";
  case 1888: return "ITexture_getPixelColor";
  case 1889: return "ITexture_getPixels";
  case 1890: return "VisualizerOptions_verbose_get";
  case 1891: return "VisualizerOptions_verbose_set";
  case 1892: return "VisualizerOptions_winWidth_get";
  case 1893: return "VisualizerOptions_winWidth_set";
  case 1894: return "VisualizerOptions_winHeight_get";
  case 1895: return "VisualizerOptions_winHeight_set";
  case 1896: return "VisualizerOptions_rootFrameArrowsDimension_get";
  case 1897: return "VisualizerOptions_rootFrameArrowsDimension_set";
  case 1898: return "new_VisualizerOptions";
  case 1899: return "delete_VisualizerOptions";
  case 1900: return "delete_ITexturesHandler";
  case 1901: return "ITexturesHandler_add";
  case 1902: return "ITexturesHandler_get";
  case 1903: return "new_Visualizer";
  case 1904: return "delete_Visualizer";
  case 1905: return "Visualizer_init";
  case 1906: return "Visualizer_getNrOfVisualizedModels";
  case 1907: return "Visualizer_getModelInstanceName";
  case 1908: return "Visualizer_getModelInstanceIndex";
  case 1909: return "Visualizer_addModel";
  case 1910: return "Visualizer_modelViz";
  case 1911: return "Visualizer_camera";
  case 1912: return "Visualizer_enviroment";
  case 1913: return "Visualizer_vectors";
  case 1914: return "Visualizer_frames";
  case 1915: return "Visualizer_textures";
  case 1916: return "Visualizer_run";
  case 1917: return "Visualizer_draw";
  case 1918: return "Visualizer_drawToFile";
  case 1919: return "Visualizer_close";
  case 1920: return "Visualizer_isWindowActive";
  case 1921: return "Polygon_m_vertices_get";
  case 1922: return "Polygon_m_vertices_set";
  case 1923: return "new_Polygon";
  case 1924: return "Polygon_setNrOfVertices";
  case 1925: return "Polygon_getNrOfVertices";
  case 1926: return "Polygon_isValid";
  case 1927: return "Polygon_applyTransform";
  case 1928: return "Polygon_paren";
  case 1929: return "Polygon_XYRectangleFromOffsets";
  case 1930: return "delete_Polygon";
  case 1931: return "Polygon2D_m_vertices_get";
  case 1932: return "Polygon2D_m_vertices_set";
  case 1933: return "new_Polygon2D";
  case 1934: return "Polygon2D_setNrOfVertices";
  case 1935: return "Polygon2D_getNrOfVertices";
  case 1936: return "Polygon2D_isValid";
  case 1937: return "Polygon2D_paren";
  case 1938: return "delete_Polygon2D";
  case 1939: return "ConvexHullProjectionConstraint_setActive";
  case 1940: return "ConvexHullProjectionConstraint_isActive";
  case 1941: return "ConvexHullProjectionConstraint_getNrOfConstraints";
  case 1942: return "ConvexHullProjectionConstraint_projectedConvexHull_get";
  case 1943: return "ConvexHullProjectionConstraint_projectedConvexHull_set";
  case 1944: return "ConvexHullProjectionConstraint_A_get";
  case 1945: return "ConvexHullProjectionConstraint_A_set";
  case 1946: return "ConvexHullProjectionConstraint_b_get";
  case 1947: return "ConvexHullProjectionConstraint_b_set";
  case 1948: return "ConvexHullProjectionConstraint_P_get";
  case 1949: return "ConvexHullProjectionConstraint_P_set";
  case 1950: return "ConvexHullProjectionConstraint_Pdirection_get";
  case 1951: return "ConvexHullProjectionConstraint_Pdirection_set";
  case 1952: return "ConvexHullProjectionConstraint_AtimesP_get";
  case 1953: return "ConvexHullProjectionConstraint_AtimesP_set";
  case 1954: return "ConvexHullProjectionConstraint_o_get";
  case 1955: return "ConvexHullProjectionConstraint_o_set";
  case 1956: return "ConvexHullProjectionConstraint_buildConvexHull";
  case 1957: return "ConvexHullProjectionConstraint_supportFrameIndices_get";
  case 1958: return "ConvexHullProjectionConstraint_supportFrameIndices_set";
  case 1959: return "ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_get";
  case 1960: return "ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_set";
  case 1961: return "ConvexHullProjectionConstraint_project";
  case 1962: return "ConvexHullProjectionConstraint_computeMargin";
  case 1963: return "ConvexHullProjectionConstraint_setProjectionAlongDirection";
  case 1964: return "ConvexHullProjectionConstraint_projectAlongDirection";
  case 1965: return "new_ConvexHullProjectionConstraint";
  case 1966: return "delete_ConvexHullProjectionConstraint";
  case 1967: return "_wrap_sizeOfRotationParametrization";
  case 1968: return "new_InverseKinematics";
  case 1969: return "delete_InverseKinematics";
  case 1970: return "InverseKinematics_loadModelFromFile";
  case 1971: return "InverseKinematics_setModel";
  case 1972: return "InverseKinematics_setJointLimits";
  case 1973: return "InverseKinematics_getJointLimits";
  case 1974: return "InverseKinematics_clearProblem";
  case 1975: return "InverseKinematics_setFloatingBaseOnFrameNamed";
  case 1976: return "InverseKinematics_setCurrentRobotConfiguration";
  case 1977: return "InverseKinematics_setJointConfiguration";
  case 1978: return "InverseKinematics_setRotationParametrization";
  case 1979: return "InverseKinematics_rotationParametrization";
  case 1980: return "InverseKinematics_setMaxIterations";
  case 1981: return "InverseKinematics_maxIterations";
  case 1982: return "InverseKinematics_setMaxCPUTime";
  case 1983: return "InverseKinematics_maxCPUTime";
  case 1984: return "InverseKinematics_setCostTolerance";
  case 1985: return "InverseKinematics_costTolerance";
  case 1986: return "InverseKinematics_setConstraintsTolerance";
  case 1987: return "InverseKinematics_constraintsTolerance";
  case 1988: return "InverseKinematics_setVerbosity";
  case 1989: return "InverseKinematics_linearSolverName";
  case 1990: return "InverseKinematics_setLinearSolverName";
  case 1991: return "InverseKinematics_addFrameConstraint";
  case 1992: return "InverseKinematics_addFramePositionConstraint";
  case 1993: return "InverseKinematics_addFrameRotationConstraint";
  case 1994: return "InverseKinematics_activateFrameConstraint";
  case 1995: return "InverseKinematics_deactivateFrameConstraint";
  case 1996: return "InverseKinematics_isFrameConstraintActive";
  case 1997: return "InverseKinematics_addCenterOfMassProjectionConstraint";
  case 1998: return "InverseKinematics_getCenterOfMassProjectionMargin";
  case 1999: return "InverseKinematics_getCenterOfMassProjectConstraintConvexHull";
  case 2000: return "InverseKinematics_addTarget";
  case 2001: return "InverseKinematics_addPositionTarget";
  case 2002: return "InverseKinematics_addRotationTarget";
  case 2003: return "InverseKinematics_updateTarget";
  case 2004: return "InverseKinematics_updatePositionTarget";
  case 2005: return "InverseKinematics_updateRotationTarget";
  case 2006: return "InverseKinematics_setDefaultTargetResolutionMode";
  case 2007: return "InverseKinematics_defaultTargetResolutionMode";
  case 2008: return "InverseKinematics_setTargetResolutionMode";
  case 2009: return "InverseKinematics_targetResolutionMode";
  case 2010: return "InverseKinematics_setDesiredFullJointsConfiguration";
  case 2011: return "InverseKinematics_setDesiredReducedJointConfiguration";
  case 2012: return "InverseKinematics_setFullJointsInitialCondition";
  case 2013: return "InverseKinematics_setReducedInitialCondition";
  case 2014: return "InverseKinematics_solve";
  case 2015: return "InverseKinematics_getFullJointsSolution";
  case 2016: return "InverseKinematics_getReducedSolution";
  case 2017: return "InverseKinematics_getPoseForFrame";
  case 2018: return "InverseKinematics_fullModel";
  case 2019: return "InverseKinematics_reducedModel";
  case 2020: return "InverseKinematics_setCOMTarget";
  case 2021: return "InverseKinematics_setCOMAsConstraint";
  case 2022: return "InverseKinematics_setCOMAsConstraintTolerance";
  case 2023: return "InverseKinematics_isCOMAConstraint";
  case 2024: return "InverseKinematics_isCOMTargetActive";
  case 2025: return "InverseKinematics_deactivateCOMTarget";
  case 2026: return "InverseKinematics_setCOMConstraintProjectionDirection";
  default: return 0;
  }
}

SWIGINTERN int swigFunctionName(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc!=1 || !mxIsDouble(*argv) || mxGetNumberOfElements(*argv)!=1) {
    SWIG_Error(SWIG_RuntimeError, "This mex file should only be called from inside the .m files generated by SWIG. The input should be the function ID.");
    return 1;
  }
  if (resc!=1) {
    SWIG_Error(SWIG_RuntimeError, "The function should have one output.");
    return 1;
  }
  int fcn_id = (int)mxGetScalar(*argv);
  const char* s = SwigFunctionName(fcn_id);
  if (s==0) {
    SWIG_Error(SWIG_RuntimeError, "No such function ID.");
    return 1;
  }
  *resv = mxCreateString(s);
  return 0;
}

SWIGINTERN int swigThis(int resc, mxArray *resv[], int argc, mxArray *argv[]) {
  if (argc!=1 || resc!=1) {
    SWIG_Error(SWIG_RuntimeError, "swigThis should have one input and one output.");
    return 1;
  }
  SwigPtr* swig_ptr = SWIG_Matlab_getSwigPtr(argv[0]);
  if (!swig_ptr) {
    SWIG_Error(SWIG_RuntimeError, "The argument should be a SWIG class.");
    return 1;
  }
  resv[0] = mxCreateNumericMatrix(1, 1, mxUINT64_CLASS, mxREAL);
  *(uint64_T *)mxGetData(resv[0]) = (uint64_T)swig_ptr->ptr;
  return 0;
}

SWIGINTERN int swigTouch(int resc, mxArray** SWIGUNUSEDPARM(resv), int argc, mxArray** SWIGUNUSEDPARM(argv)) {
  if (argc!=0 || resc!=0) {
    SWIG_Error(SWIG_RuntimeError, "swigTouch should have no inputs or outputs.");
    return 1;
  }
  return 0;
}

extern "C"
void mexFunction(int resc, mxArray *resv[], int argc, const mxArray *argv[]) {
  /* Initialize module if first call */
  SWIG_Matlab_LoadModule();

  if (--argc < 0 || !mxIsDouble(*argv) || mxGetNumberOfElements(*argv)!=1)
    mexErrMsgTxt("This mex file should only be called from inside the .m files generated by SWIG. First input should be the function ID .");
  int fcn_id = (int)mxGetScalar(*argv++);
  int flag=0;
  switch (fcn_id) {
  case 0: flag=swigConstant(resc,resv,argc,(mxArray**)(argv)); break;
  case 1: flag=swigFunctionName(resc,resv,argc,(mxArray**)(argv)); break;
  case 2: flag=swigConstantName(resc,resv,argc,(mxArray**)(argv)); break;
  case 3: flag=swigThis(resc,resv,argc,(mxArray**)(argv)); break;
  case 4: flag=swigTouch(resc,resv,argc,(mxArray**)(argv)); break;
  case 5: flag=_wrap_delete_MatlabSwigIterator(resc,resv,argc,(mxArray**)(argv)); break;
  case 6: flag=_wrap_MatlabSwigIterator_value(resc,resv,argc,(mxArray**)(argv)); break;
  case 7: flag=_wrap_MatlabSwigIterator_incr(resc,resv,argc,(mxArray**)(argv)); break;
  case 8: flag=_wrap_MatlabSwigIterator_decr(resc,resv,argc,(mxArray**)(argv)); break;
  case 9: flag=_wrap_MatlabSwigIterator_distance(resc,resv,argc,(mxArray**)(argv)); break;
  case 10: flag=_wrap_MatlabSwigIterator_equal(resc,resv,argc,(mxArray**)(argv)); break;
  case 11: flag=_wrap_MatlabSwigIterator_copy(resc,resv,argc,(mxArray**)(argv)); break;
  case 12: flag=_wrap_MatlabSwigIterator_next(resc,resv,argc,(mxArray**)(argv)); break;
  case 13: flag=_wrap_MatlabSwigIterator_previous(resc,resv,argc,(mxArray**)(argv)); break;
  case 14: flag=_wrap_MatlabSwigIterator_advance(resc,resv,argc,(mxArray**)(argv)); break;
  case 15: flag=_wrap_MatlabSwigIterator_eq(resc,resv,argc,(mxArray**)(argv)); break;
  case 16: flag=_wrap_MatlabSwigIterator_ne(resc,resv,argc,(mxArray**)(argv)); break;
  case 17: flag=_wrap_MatlabSwigIterator_TODOincr(resc,resv,argc,(mxArray**)(argv)); break;
  case 18: flag=_wrap_MatlabSwigIterator_TODOdecr(resc,resv,argc,(mxArray**)(argv)); break;
  case 19: flag=_wrap_MatlabSwigIterator_plus(resc,resv,argc,(mxArray**)(argv)); break;
  case 20: flag=_wrap_MatlabSwigIterator_minus(resc,resv,argc,(mxArray**)(argv)); break;
  case 21: flag=_wrap_StringVector_pop(resc,resv,argc,(mxArray**)(argv)); break;
  case 22: flag=_wrap_StringVector_brace(resc,resv,argc,(mxArray**)(argv)); break;
  case 23: flag=_wrap_StringVector_setbrace(resc,resv,argc,(mxArray**)(argv)); break;
  case 24: flag=_wrap_StringVector_append(resc,resv,argc,(mxArray**)(argv)); break;
  case 25: flag=_wrap_StringVector_empty(resc,resv,argc,(mxArray**)(argv)); break;
  case 26: flag=_wrap_StringVector_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 27: flag=_wrap_StringVector_swap(resc,resv,argc,(mxArray**)(argv)); break;
  case 28: flag=_wrap_StringVector_begin(resc,resv,argc,(mxArray**)(argv)); break;
  case 29: flag=_wrap_StringVector_end(resc,resv,argc,(mxArray**)(argv)); break;
  case 30: flag=_wrap_StringVector_rbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 31: flag=_wrap_StringVector_rend(resc,resv,argc,(mxArray**)(argv)); break;
  case 32: flag=_wrap_StringVector_clear(resc,resv,argc,(mxArray**)(argv)); break;
  case 33: flag=_wrap_StringVector_get_allocator(resc,resv,argc,(mxArray**)(argv)); break;
  case 34: flag=_wrap_StringVector_pop_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 35: flag=_wrap_StringVector_erase(resc,resv,argc,(mxArray**)(argv)); break;
  case 36: flag=_wrap_new_StringVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 37: flag=_wrap_StringVector_push_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 38: flag=_wrap_StringVector_front(resc,resv,argc,(mxArray**)(argv)); break;
  case 39: flag=_wrap_StringVector_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 40: flag=_wrap_StringVector_assign(resc,resv,argc,(mxArray**)(argv)); break;
  case 41: flag=_wrap_StringVector_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 42: flag=_wrap_StringVector_insert(resc,resv,argc,(mxArray**)(argv)); break;
  case 43: flag=_wrap_StringVector_reserve(resc,resv,argc,(mxArray**)(argv)); break;
  case 44: flag=_wrap_StringVector_capacity(resc,resv,argc,(mxArray**)(argv)); break;
  case 45: flag=_wrap_delete_StringVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 46: flag=_wrap_IntVector_pop(resc,resv,argc,(mxArray**)(argv)); break;
  case 47: flag=_wrap_IntVector_brace(resc,resv,argc,(mxArray**)(argv)); break;
  case 48: flag=_wrap_IntVector_setbrace(resc,resv,argc,(mxArray**)(argv)); break;
  case 49: flag=_wrap_IntVector_append(resc,resv,argc,(mxArray**)(argv)); break;
  case 50: flag=_wrap_IntVector_empty(resc,resv,argc,(mxArray**)(argv)); break;
  case 51: flag=_wrap_IntVector_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 52: flag=_wrap_IntVector_swap(resc,resv,argc,(mxArray**)(argv)); break;
  case 53: flag=_wrap_IntVector_begin(resc,resv,argc,(mxArray**)(argv)); break;
  case 54: flag=_wrap_IntVector_end(resc,resv,argc,(mxArray**)(argv)); break;
  case 55: flag=_wrap_IntVector_rbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 56: flag=_wrap_IntVector_rend(resc,resv,argc,(mxArray**)(argv)); break;
  case 57: flag=_wrap_IntVector_clear(resc,resv,argc,(mxArray**)(argv)); break;
  case 58: flag=_wrap_IntVector_get_allocator(resc,resv,argc,(mxArray**)(argv)); break;
  case 59: flag=_wrap_IntVector_pop_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 60: flag=_wrap_IntVector_erase(resc,resv,argc,(mxArray**)(argv)); break;
  case 61: flag=_wrap_new_IntVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 62: flag=_wrap_IntVector_push_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 63: flag=_wrap_IntVector_front(resc,resv,argc,(mxArray**)(argv)); break;
  case 64: flag=_wrap_IntVector_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 65: flag=_wrap_IntVector_assign(resc,resv,argc,(mxArray**)(argv)); break;
  case 66: flag=_wrap_IntVector_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 67: flag=_wrap_IntVector_insert(resc,resv,argc,(mxArray**)(argv)); break;
  case 68: flag=_wrap_IntVector_reserve(resc,resv,argc,(mxArray**)(argv)); break;
  case 69: flag=_wrap_IntVector_capacity(resc,resv,argc,(mxArray**)(argv)); break;
  case 70: flag=_wrap_delete_IntVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 71: flag=_wrap_BerdySensors_pop(resc,resv,argc,(mxArray**)(argv)); break;
  case 72: flag=_wrap_BerdySensors_brace(resc,resv,argc,(mxArray**)(argv)); break;
  case 73: flag=_wrap_BerdySensors_setbrace(resc,resv,argc,(mxArray**)(argv)); break;
  case 74: flag=_wrap_BerdySensors_append(resc,resv,argc,(mxArray**)(argv)); break;
  case 75: flag=_wrap_BerdySensors_empty(resc,resv,argc,(mxArray**)(argv)); break;
  case 76: flag=_wrap_BerdySensors_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 77: flag=_wrap_BerdySensors_swap(resc,resv,argc,(mxArray**)(argv)); break;
  case 78: flag=_wrap_BerdySensors_begin(resc,resv,argc,(mxArray**)(argv)); break;
  case 79: flag=_wrap_BerdySensors_end(resc,resv,argc,(mxArray**)(argv)); break;
  case 80: flag=_wrap_BerdySensors_rbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 81: flag=_wrap_BerdySensors_rend(resc,resv,argc,(mxArray**)(argv)); break;
  case 82: flag=_wrap_BerdySensors_clear(resc,resv,argc,(mxArray**)(argv)); break;
  case 83: flag=_wrap_BerdySensors_get_allocator(resc,resv,argc,(mxArray**)(argv)); break;
  case 84: flag=_wrap_BerdySensors_pop_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 85: flag=_wrap_BerdySensors_erase(resc,resv,argc,(mxArray**)(argv)); break;
  case 86: flag=_wrap_new_BerdySensors(resc,resv,argc,(mxArray**)(argv)); break;
  case 87: flag=_wrap_BerdySensors_push_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 88: flag=_wrap_BerdySensors_front(resc,resv,argc,(mxArray**)(argv)); break;
  case 89: flag=_wrap_BerdySensors_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 90: flag=_wrap_BerdySensors_assign(resc,resv,argc,(mxArray**)(argv)); break;
  case 91: flag=_wrap_BerdySensors_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 92: flag=_wrap_BerdySensors_insert(resc,resv,argc,(mxArray**)(argv)); break;
  case 93: flag=_wrap_BerdySensors_reserve(resc,resv,argc,(mxArray**)(argv)); break;
  case 94: flag=_wrap_BerdySensors_capacity(resc,resv,argc,(mxArray**)(argv)); break;
  case 95: flag=_wrap_delete_BerdySensors(resc,resv,argc,(mxArray**)(argv)); break;
  case 96: flag=_wrap_BerdyDynamicVariables_pop(resc,resv,argc,(mxArray**)(argv)); break;
  case 97: flag=_wrap_BerdyDynamicVariables_brace(resc,resv,argc,(mxArray**)(argv)); break;
  case 98: flag=_wrap_BerdyDynamicVariables_setbrace(resc,resv,argc,(mxArray**)(argv)); break;
  case 99: flag=_wrap_BerdyDynamicVariables_append(resc,resv,argc,(mxArray**)(argv)); break;
  case 100: flag=_wrap_BerdyDynamicVariables_empty(resc,resv,argc,(mxArray**)(argv)); break;
  case 101: flag=_wrap_BerdyDynamicVariables_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 102: flag=_wrap_BerdyDynamicVariables_swap(resc,resv,argc,(mxArray**)(argv)); break;
  case 103: flag=_wrap_BerdyDynamicVariables_begin(resc,resv,argc,(mxArray**)(argv)); break;
  case 104: flag=_wrap_BerdyDynamicVariables_end(resc,resv,argc,(mxArray**)(argv)); break;
  case 105: flag=_wrap_BerdyDynamicVariables_rbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 106: flag=_wrap_BerdyDynamicVariables_rend(resc,resv,argc,(mxArray**)(argv)); break;
  case 107: flag=_wrap_BerdyDynamicVariables_clear(resc,resv,argc,(mxArray**)(argv)); break;
  case 108: flag=_wrap_BerdyDynamicVariables_get_allocator(resc,resv,argc,(mxArray**)(argv)); break;
  case 109: flag=_wrap_BerdyDynamicVariables_pop_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 110: flag=_wrap_BerdyDynamicVariables_erase(resc,resv,argc,(mxArray**)(argv)); break;
  case 111: flag=_wrap_new_BerdyDynamicVariables(resc,resv,argc,(mxArray**)(argv)); break;
  case 112: flag=_wrap_BerdyDynamicVariables_push_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 113: flag=_wrap_BerdyDynamicVariables_front(resc,resv,argc,(mxArray**)(argv)); break;
  case 114: flag=_wrap_BerdyDynamicVariables_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 115: flag=_wrap_BerdyDynamicVariables_assign(resc,resv,argc,(mxArray**)(argv)); break;
  case 116: flag=_wrap_BerdyDynamicVariables_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 117: flag=_wrap_BerdyDynamicVariables_insert(resc,resv,argc,(mxArray**)(argv)); break;
  case 118: flag=_wrap_BerdyDynamicVariables_reserve(resc,resv,argc,(mxArray**)(argv)); break;
  case 119: flag=_wrap_BerdyDynamicVariables_capacity(resc,resv,argc,(mxArray**)(argv)); break;
  case 120: flag=_wrap_delete_BerdyDynamicVariables(resc,resv,argc,(mxArray**)(argv)); break;
  case 121: flag=_wrap_reportInfo(resc,resv,argc,(mxArray**)(argv)); break;
  case 122: flag=_wrap_reportDebug(resc,resv,argc,(mxArray**)(argv)); break;
  case 123: flag=_wrap_IndexRange_offset_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 124: flag=_wrap_IndexRange_offset_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 125: flag=_wrap_IndexRange_size_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 126: flag=_wrap_IndexRange_size_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 127: flag=_wrap_IndexRange_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 128: flag=_wrap_IndexRange_InvalidRange(resc,resv,argc,(mxArray**)(argv)); break;
  case 129: flag=_wrap_new_IndexRange(resc,resv,argc,(mxArray**)(argv)); break;
  case 130: flag=_wrap_delete_IndexRange(resc,resv,argc,(mxArray**)(argv)); break;
  case 131: flag=_wrap_checkDoublesAreEqual(resc,resv,argc,(mxArray**)(argv)); break;
  case 132: flag=_wrap_new_MatrixDynSize(resc,resv,argc,(mxArray**)(argv)); break;
  case 133: flag=_wrap_delete_MatrixDynSize(resc,resv,argc,(mxArray**)(argv)); break;
  case 134: flag=_wrap_MatrixDynSize_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 135: flag=_wrap_MatrixDynSize_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 136: flag=_wrap_MatrixDynSize_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 137: flag=_wrap_MatrixDynSize_rows(resc,resv,argc,(mxArray**)(argv)); break;
  case 138: flag=_wrap_MatrixDynSize_cols(resc,resv,argc,(mxArray**)(argv)); break;
  case 139: flag=_wrap_MatrixDynSize_data(resc,resv,argc,(mxArray**)(argv)); break;
  case 140: flag=_wrap_MatrixDynSize_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 141: flag=_wrap_MatrixDynSize_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 142: flag=_wrap_MatrixDynSize_reserve(resc,resv,argc,(mxArray**)(argv)); break;
  case 143: flag=_wrap_MatrixDynSize_capacity(resc,resv,argc,(mxArray**)(argv)); break;
  case 144: flag=_wrap_MatrixDynSize_shrink_to_fit(resc,resv,argc,(mxArray**)(argv)); break;
  case 145: flag=_wrap_MatrixDynSize_fillRowMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 146: flag=_wrap_MatrixDynSize_fillColMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 147: flag=_wrap_MatrixDynSize_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 148: flag=_wrap_MatrixDynSize_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 149: flag=_wrap_MatrixDynSize_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 150: flag=_wrap_MatrixDynSize_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 151: flag=_wrap_new_SparseMatrixRowMajor(resc,resv,argc,(mxArray**)(argv)); break;
  case 152: flag=_wrap_delete_SparseMatrixRowMajor(resc,resv,argc,(mxArray**)(argv)); break;
  case 153: flag=_wrap_SparseMatrixRowMajor_numberOfNonZeros(resc,resv,argc,(mxArray**)(argv)); break;
  case 154: flag=_wrap_SparseMatrixRowMajor_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 155: flag=_wrap_SparseMatrixRowMajor_reserve(resc,resv,argc,(mxArray**)(argv)); break;
  case 156: flag=_wrap_SparseMatrixRowMajor_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 157: flag=_wrap_SparseMatrixRowMajor_setFromConstTriplets(resc,resv,argc,(mxArray**)(argv)); break;
  case 158: flag=_wrap_SparseMatrixRowMajor_setFromTriplets(resc,resv,argc,(mxArray**)(argv)); break;
  case 159: flag=_wrap_SparseMatrixRowMajor_sparseMatrixFromTriplets(resc,resv,argc,(mxArray**)(argv)); break;
  case 160: flag=_wrap_SparseMatrixRowMajor_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 161: flag=_wrap_SparseMatrixRowMajor_getValue(resc,resv,argc,(mxArray**)(argv)); break;
  case 162: flag=_wrap_SparseMatrixRowMajor_setValue(resc,resv,argc,(mxArray**)(argv)); break;
  case 163: flag=_wrap_SparseMatrixRowMajor_rows(resc,resv,argc,(mxArray**)(argv)); break;
  case 164: flag=_wrap_SparseMatrixRowMajor_columns(resc,resv,argc,(mxArray**)(argv)); break;
  case 165: flag=_wrap_SparseMatrixRowMajor_description(resc,resv,argc,(mxArray**)(argv)); break;
  case 166: flag=_wrap_SparseMatrixRowMajor_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 167: flag=_wrap_SparseMatrixRowMajor_toMatlabDense(resc,resv,argc,(mxArray**)(argv)); break;
  case 168: flag=_wrap_SparseMatrixRowMajor_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 169: flag=_wrap_new_SparseMatrixColMajor(resc,resv,argc,(mxArray**)(argv)); break;
  case 170: flag=_wrap_delete_SparseMatrixColMajor(resc,resv,argc,(mxArray**)(argv)); break;
  case 171: flag=_wrap_SparseMatrixColMajor_numberOfNonZeros(resc,resv,argc,(mxArray**)(argv)); break;
  case 172: flag=_wrap_SparseMatrixColMajor_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 173: flag=_wrap_SparseMatrixColMajor_reserve(resc,resv,argc,(mxArray**)(argv)); break;
  case 174: flag=_wrap_SparseMatrixColMajor_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 175: flag=_wrap_SparseMatrixColMajor_setFromConstTriplets(resc,resv,argc,(mxArray**)(argv)); break;
  case 176: flag=_wrap_SparseMatrixColMajor_setFromTriplets(resc,resv,argc,(mxArray**)(argv)); break;
  case 177: flag=_wrap_SparseMatrixColMajor_sparseMatrixFromTriplets(resc,resv,argc,(mxArray**)(argv)); break;
  case 178: flag=_wrap_SparseMatrixColMajor_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 179: flag=_wrap_SparseMatrixColMajor_getValue(resc,resv,argc,(mxArray**)(argv)); break;
  case 180: flag=_wrap_SparseMatrixColMajor_setValue(resc,resv,argc,(mxArray**)(argv)); break;
  case 181: flag=_wrap_SparseMatrixColMajor_rows(resc,resv,argc,(mxArray**)(argv)); break;
  case 182: flag=_wrap_SparseMatrixColMajor_columns(resc,resv,argc,(mxArray**)(argv)); break;
  case 183: flag=_wrap_SparseMatrixColMajor_description(resc,resv,argc,(mxArray**)(argv)); break;
  case 184: flag=_wrap_SparseMatrixColMajor_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 185: flag=_wrap_SparseMatrixColMajor_toMatlabDense(resc,resv,argc,(mxArray**)(argv)); break;
  case 186: flag=_wrap_SparseMatrixColMajor_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 187: flag=_wrap_new_VectorDynSize(resc,resv,argc,(mxArray**)(argv)); break;
  case 188: flag=_wrap_delete_VectorDynSize(resc,resv,argc,(mxArray**)(argv)); break;
  case 189: flag=_wrap_VectorDynSize_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 190: flag=_wrap_VectorDynSize_brace(resc,resv,argc,(mxArray**)(argv)); break;
  case 191: flag=_wrap_VectorDynSize_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 192: flag=_wrap_VectorDynSize_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 193: flag=_wrap_VectorDynSize_cbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 194: flag=_wrap_VectorDynSize_cend(resc,resv,argc,(mxArray**)(argv)); break;
  case 195: flag=_wrap_VectorDynSize_begin(resc,resv,argc,(mxArray**)(argv)); break;
  case 196: flag=_wrap_VectorDynSize_end(resc,resv,argc,(mxArray**)(argv)); break;
  case 197: flag=_wrap_VectorDynSize_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 198: flag=_wrap_VectorDynSize_data(resc,resv,argc,(mxArray**)(argv)); break;
  case 199: flag=_wrap_VectorDynSize_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 200: flag=_wrap_VectorDynSize_reserve(resc,resv,argc,(mxArray**)(argv)); break;
  case 201: flag=_wrap_VectorDynSize_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 202: flag=_wrap_VectorDynSize_shrink_to_fit(resc,resv,argc,(mxArray**)(argv)); break;
  case 203: flag=_wrap_VectorDynSize_capacity(resc,resv,argc,(mxArray**)(argv)); break;
  case 204: flag=_wrap_VectorDynSize_fillBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 205: flag=_wrap_VectorDynSize_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 206: flag=_wrap_VectorDynSize_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 207: flag=_wrap_VectorDynSize_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 208: flag=_wrap_VectorDynSize_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 209: flag=_wrap_new_Matrix1x6(resc,resv,argc,(mxArray**)(argv)); break;
  case 210: flag=_wrap_Matrix1x6_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 211: flag=_wrap_Matrix1x6_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 212: flag=_wrap_Matrix1x6_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 213: flag=_wrap_Matrix1x6_rows(resc,resv,argc,(mxArray**)(argv)); break;
  case 214: flag=_wrap_Matrix1x6_cols(resc,resv,argc,(mxArray**)(argv)); break;
  case 215: flag=_wrap_Matrix1x6_data(resc,resv,argc,(mxArray**)(argv)); break;
  case 216: flag=_wrap_Matrix1x6_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 217: flag=_wrap_Matrix1x6_fillRowMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 218: flag=_wrap_Matrix1x6_fillColMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 219: flag=_wrap_Matrix1x6_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 220: flag=_wrap_Matrix1x6_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 221: flag=_wrap_Matrix1x6_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 222: flag=_wrap_Matrix1x6_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 223: flag=_wrap_delete_Matrix1x6(resc,resv,argc,(mxArray**)(argv)); break;
  case 224: flag=_wrap_new_Matrix2x3(resc,resv,argc,(mxArray**)(argv)); break;
  case 225: flag=_wrap_Matrix2x3_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 226: flag=_wrap_Matrix2x3_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 227: flag=_wrap_Matrix2x3_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 228: flag=_wrap_Matrix2x3_rows(resc,resv,argc,(mxArray**)(argv)); break;
  case 229: flag=_wrap_Matrix2x3_cols(resc,resv,argc,(mxArray**)(argv)); break;
  case 230: flag=_wrap_Matrix2x3_data(resc,resv,argc,(mxArray**)(argv)); break;
  case 231: flag=_wrap_Matrix2x3_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 232: flag=_wrap_Matrix2x3_fillRowMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 233: flag=_wrap_Matrix2x3_fillColMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 234: flag=_wrap_Matrix2x3_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 235: flag=_wrap_Matrix2x3_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 236: flag=_wrap_Matrix2x3_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 237: flag=_wrap_Matrix2x3_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 238: flag=_wrap_delete_Matrix2x3(resc,resv,argc,(mxArray**)(argv)); break;
  case 239: flag=_wrap_new_Matrix3x3(resc,resv,argc,(mxArray**)(argv)); break;
  case 240: flag=_wrap_Matrix3x3_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 241: flag=_wrap_Matrix3x3_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 242: flag=_wrap_Matrix3x3_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 243: flag=_wrap_Matrix3x3_rows(resc,resv,argc,(mxArray**)(argv)); break;
  case 244: flag=_wrap_Matrix3x3_cols(resc,resv,argc,(mxArray**)(argv)); break;
  case 245: flag=_wrap_Matrix3x3_data(resc,resv,argc,(mxArray**)(argv)); break;
  case 246: flag=_wrap_Matrix3x3_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 247: flag=_wrap_Matrix3x3_fillRowMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 248: flag=_wrap_Matrix3x3_fillColMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 249: flag=_wrap_Matrix3x3_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 250: flag=_wrap_Matrix3x3_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 251: flag=_wrap_Matrix3x3_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 252: flag=_wrap_Matrix3x3_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 253: flag=_wrap_delete_Matrix3x3(resc,resv,argc,(mxArray**)(argv)); break;
  case 254: flag=_wrap_new_Matrix4x4(resc,resv,argc,(mxArray**)(argv)); break;
  case 255: flag=_wrap_Matrix4x4_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 256: flag=_wrap_Matrix4x4_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 257: flag=_wrap_Matrix4x4_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 258: flag=_wrap_Matrix4x4_rows(resc,resv,argc,(mxArray**)(argv)); break;
  case 259: flag=_wrap_Matrix4x4_cols(resc,resv,argc,(mxArray**)(argv)); break;
  case 260: flag=_wrap_Matrix4x4_data(resc,resv,argc,(mxArray**)(argv)); break;
  case 261: flag=_wrap_Matrix4x4_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 262: flag=_wrap_Matrix4x4_fillRowMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 263: flag=_wrap_Matrix4x4_fillColMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 264: flag=_wrap_Matrix4x4_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 265: flag=_wrap_Matrix4x4_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 266: flag=_wrap_Matrix4x4_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 267: flag=_wrap_Matrix4x4_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 268: flag=_wrap_delete_Matrix4x4(resc,resv,argc,(mxArray**)(argv)); break;
  case 269: flag=_wrap_new_Matrix6x6(resc,resv,argc,(mxArray**)(argv)); break;
  case 270: flag=_wrap_Matrix6x6_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 271: flag=_wrap_Matrix6x6_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 272: flag=_wrap_Matrix6x6_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 273: flag=_wrap_Matrix6x6_rows(resc,resv,argc,(mxArray**)(argv)); break;
  case 274: flag=_wrap_Matrix6x6_cols(resc,resv,argc,(mxArray**)(argv)); break;
  case 275: flag=_wrap_Matrix6x6_data(resc,resv,argc,(mxArray**)(argv)); break;
  case 276: flag=_wrap_Matrix6x6_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 277: flag=_wrap_Matrix6x6_fillRowMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 278: flag=_wrap_Matrix6x6_fillColMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 279: flag=_wrap_Matrix6x6_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 280: flag=_wrap_Matrix6x6_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 281: flag=_wrap_Matrix6x6_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 282: flag=_wrap_Matrix6x6_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 283: flag=_wrap_delete_Matrix6x6(resc,resv,argc,(mxArray**)(argv)); break;
  case 284: flag=_wrap_new_Matrix6x10(resc,resv,argc,(mxArray**)(argv)); break;
  case 285: flag=_wrap_Matrix6x10_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 286: flag=_wrap_Matrix6x10_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 287: flag=_wrap_Matrix6x10_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 288: flag=_wrap_Matrix6x10_rows(resc,resv,argc,(mxArray**)(argv)); break;
  case 289: flag=_wrap_Matrix6x10_cols(resc,resv,argc,(mxArray**)(argv)); break;
  case 290: flag=_wrap_Matrix6x10_data(resc,resv,argc,(mxArray**)(argv)); break;
  case 291: flag=_wrap_Matrix6x10_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 292: flag=_wrap_Matrix6x10_fillRowMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 293: flag=_wrap_Matrix6x10_fillColMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 294: flag=_wrap_Matrix6x10_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 295: flag=_wrap_Matrix6x10_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 296: flag=_wrap_Matrix6x10_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 297: flag=_wrap_Matrix6x10_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 298: flag=_wrap_delete_Matrix6x10(resc,resv,argc,(mxArray**)(argv)); break;
  case 299: flag=_wrap_new_Matrix10x16(resc,resv,argc,(mxArray**)(argv)); break;
  case 300: flag=_wrap_Matrix10x16_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 301: flag=_wrap_Matrix10x16_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 302: flag=_wrap_Matrix10x16_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 303: flag=_wrap_Matrix10x16_rows(resc,resv,argc,(mxArray**)(argv)); break;
  case 304: flag=_wrap_Matrix10x16_cols(resc,resv,argc,(mxArray**)(argv)); break;
  case 305: flag=_wrap_Matrix10x16_data(resc,resv,argc,(mxArray**)(argv)); break;
  case 306: flag=_wrap_Matrix10x16_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 307: flag=_wrap_Matrix10x16_fillRowMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 308: flag=_wrap_Matrix10x16_fillColMajorBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 309: flag=_wrap_Matrix10x16_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 310: flag=_wrap_Matrix10x16_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 311: flag=_wrap_Matrix10x16_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 312: flag=_wrap_Matrix10x16_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 313: flag=_wrap_delete_Matrix10x16(resc,resv,argc,(mxArray**)(argv)); break;
  case 314: flag=_wrap_new_Vector3(resc,resv,argc,(mxArray**)(argv)); break;
  case 315: flag=_wrap_Vector3_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 316: flag=_wrap_Vector3_brace(resc,resv,argc,(mxArray**)(argv)); break;
  case 317: flag=_wrap_Vector3_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 318: flag=_wrap_Vector3_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 319: flag=_wrap_Vector3_cbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 320: flag=_wrap_Vector3_cend(resc,resv,argc,(mxArray**)(argv)); break;
  case 321: flag=_wrap_Vector3_begin(resc,resv,argc,(mxArray**)(argv)); break;
  case 322: flag=_wrap_Vector3_end(resc,resv,argc,(mxArray**)(argv)); break;
  case 323: flag=_wrap_Vector3_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 324: flag=_wrap_Vector3_data(resc,resv,argc,(mxArray**)(argv)); break;
  case 325: flag=_wrap_Vector3_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 326: flag=_wrap_Vector3_fillBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 327: flag=_wrap_Vector3_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 328: flag=_wrap_Vector3_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 329: flag=_wrap_Vector3_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 330: flag=_wrap_Vector3_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 331: flag=_wrap_delete_Vector3(resc,resv,argc,(mxArray**)(argv)); break;
  case 332: flag=_wrap_new_Vector4(resc,resv,argc,(mxArray**)(argv)); break;
  case 333: flag=_wrap_Vector4_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 334: flag=_wrap_Vector4_brace(resc,resv,argc,(mxArray**)(argv)); break;
  case 335: flag=_wrap_Vector4_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 336: flag=_wrap_Vector4_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 337: flag=_wrap_Vector4_cbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 338: flag=_wrap_Vector4_cend(resc,resv,argc,(mxArray**)(argv)); break;
  case 339: flag=_wrap_Vector4_begin(resc,resv,argc,(mxArray**)(argv)); break;
  case 340: flag=_wrap_Vector4_end(resc,resv,argc,(mxArray**)(argv)); break;
  case 341: flag=_wrap_Vector4_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 342: flag=_wrap_Vector4_data(resc,resv,argc,(mxArray**)(argv)); break;
  case 343: flag=_wrap_Vector4_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 344: flag=_wrap_Vector4_fillBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 345: flag=_wrap_Vector4_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 346: flag=_wrap_Vector4_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 347: flag=_wrap_Vector4_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 348: flag=_wrap_Vector4_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 349: flag=_wrap_delete_Vector4(resc,resv,argc,(mxArray**)(argv)); break;
  case 350: flag=_wrap_new_Vector6(resc,resv,argc,(mxArray**)(argv)); break;
  case 351: flag=_wrap_Vector6_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 352: flag=_wrap_Vector6_brace(resc,resv,argc,(mxArray**)(argv)); break;
  case 353: flag=_wrap_Vector6_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 354: flag=_wrap_Vector6_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 355: flag=_wrap_Vector6_cbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 356: flag=_wrap_Vector6_cend(resc,resv,argc,(mxArray**)(argv)); break;
  case 357: flag=_wrap_Vector6_begin(resc,resv,argc,(mxArray**)(argv)); break;
  case 358: flag=_wrap_Vector6_end(resc,resv,argc,(mxArray**)(argv)); break;
  case 359: flag=_wrap_Vector6_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 360: flag=_wrap_Vector6_data(resc,resv,argc,(mxArray**)(argv)); break;
  case 361: flag=_wrap_Vector6_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 362: flag=_wrap_Vector6_fillBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 363: flag=_wrap_Vector6_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 364: flag=_wrap_Vector6_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 365: flag=_wrap_Vector6_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 366: flag=_wrap_Vector6_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 367: flag=_wrap_delete_Vector6(resc,resv,argc,(mxArray**)(argv)); break;
  case 368: flag=_wrap_new_Vector10(resc,resv,argc,(mxArray**)(argv)); break;
  case 369: flag=_wrap_Vector10_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 370: flag=_wrap_Vector10_brace(resc,resv,argc,(mxArray**)(argv)); break;
  case 371: flag=_wrap_Vector10_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 372: flag=_wrap_Vector10_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 373: flag=_wrap_Vector10_cbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 374: flag=_wrap_Vector10_cend(resc,resv,argc,(mxArray**)(argv)); break;
  case 375: flag=_wrap_Vector10_begin(resc,resv,argc,(mxArray**)(argv)); break;
  case 376: flag=_wrap_Vector10_end(resc,resv,argc,(mxArray**)(argv)); break;
  case 377: flag=_wrap_Vector10_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 378: flag=_wrap_Vector10_data(resc,resv,argc,(mxArray**)(argv)); break;
  case 379: flag=_wrap_Vector10_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 380: flag=_wrap_Vector10_fillBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 381: flag=_wrap_Vector10_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 382: flag=_wrap_Vector10_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 383: flag=_wrap_Vector10_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 384: flag=_wrap_Vector10_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 385: flag=_wrap_delete_Vector10(resc,resv,argc,(mxArray**)(argv)); break;
  case 386: flag=_wrap_new_Vector16(resc,resv,argc,(mxArray**)(argv)); break;
  case 387: flag=_wrap_Vector16_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 388: flag=_wrap_Vector16_brace(resc,resv,argc,(mxArray**)(argv)); break;
  case 389: flag=_wrap_Vector16_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 390: flag=_wrap_Vector16_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 391: flag=_wrap_Vector16_cbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 392: flag=_wrap_Vector16_cend(resc,resv,argc,(mxArray**)(argv)); break;
  case 393: flag=_wrap_Vector16_begin(resc,resv,argc,(mxArray**)(argv)); break;
  case 394: flag=_wrap_Vector16_end(resc,resv,argc,(mxArray**)(argv)); break;
  case 395: flag=_wrap_Vector16_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 396: flag=_wrap_Vector16_data(resc,resv,argc,(mxArray**)(argv)); break;
  case 397: flag=_wrap_Vector16_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 398: flag=_wrap_Vector16_fillBuffer(resc,resv,argc,(mxArray**)(argv)); break;
  case 399: flag=_wrap_Vector16_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 400: flag=_wrap_Vector16_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 401: flag=_wrap_Vector16_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 402: flag=_wrap_Vector16_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 403: flag=_wrap_delete_Vector16(resc,resv,argc,(mxArray**)(argv)); break;
  case 404: flag=_wrap_new_PositionRaw(resc,resv,argc,(mxArray**)(argv)); break;
  case 405: flag=_wrap_PositionRaw_changePoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 406: flag=_wrap_PositionRaw_changeRefPoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 407: flag=_wrap_PositionRaw_compose(resc,resv,argc,(mxArray**)(argv)); break;
  case 408: flag=_wrap_PositionRaw_inverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 409: flag=_wrap_PositionRaw_changePointOf(resc,resv,argc,(mxArray**)(argv)); break;
  case 410: flag=_wrap_PositionRaw_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 411: flag=_wrap_PositionRaw_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 412: flag=_wrap_delete_PositionRaw(resc,resv,argc,(mxArray**)(argv)); break;
  case 413: flag=_wrap_new_Position(resc,resv,argc,(mxArray**)(argv)); break;
  case 414: flag=_wrap_Position_changePoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 415: flag=_wrap_Position_changeRefPoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 416: flag=_wrap_Position_changeCoordinateFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 417: flag=_wrap_Position_compose(resc,resv,argc,(mxArray**)(argv)); break;
  case 418: flag=_wrap_Position_inverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 419: flag=_wrap_Position_changePointOf(resc,resv,argc,(mxArray**)(argv)); break;
  case 420: flag=_wrap_Position_plus(resc,resv,argc,(mxArray**)(argv)); break;
  case 421: flag=_wrap_Position_minus(resc,resv,argc,(mxArray**)(argv)); break;
  case 422: flag=_wrap_Position_uminus(resc,resv,argc,(mxArray**)(argv)); break;
  case 423: flag=_wrap_Position_mtimes(resc,resv,argc,(mxArray**)(argv)); break;
  case 424: flag=_wrap_Position_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 425: flag=_wrap_Position_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 426: flag=_wrap_Position_Zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 427: flag=_wrap_delete_Position(resc,resv,argc,(mxArray**)(argv)); break;
  case 428: flag=_wrap_new_GeomVector3(resc,resv,argc,(mxArray**)(argv)); break;
  case 429: flag=_wrap_GeomVector3_changeCoordFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 430: flag=_wrap_GeomVector3_compose(resc,resv,argc,(mxArray**)(argv)); break;
  case 431: flag=_wrap_GeomVector3_inverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 432: flag=_wrap_GeomVector3_dot(resc,resv,argc,(mxArray**)(argv)); break;
  case 433: flag=_wrap_GeomVector3_plus(resc,resv,argc,(mxArray**)(argv)); break;
  case 434: flag=_wrap_GeomVector3_minus(resc,resv,argc,(mxArray**)(argv)); break;
  case 435: flag=_wrap_GeomVector3_uminus(resc,resv,argc,(mxArray**)(argv)); break;
  case 436: flag=_wrap_GeomVector3_exp(resc,resv,argc,(mxArray**)(argv)); break;
  case 437: flag=_wrap_GeomVector3_cross(resc,resv,argc,(mxArray**)(argv)); break;
  case 438: flag=_wrap_delete_GeomVector3(resc,resv,argc,(mxArray**)(argv)); break;
  case 439: flag=_wrap_new_SpatialMotionVectorBase(resc,resv,argc,(mxArray**)(argv)); break;
  case 440: flag=_wrap_SpatialMotionVectorBase_getLinearVec3(resc,resv,argc,(mxArray**)(argv)); break;
  case 441: flag=_wrap_SpatialMotionVectorBase_getAngularVec3(resc,resv,argc,(mxArray**)(argv)); break;
  case 442: flag=_wrap_SpatialMotionVectorBase_setLinearVec3(resc,resv,argc,(mxArray**)(argv)); break;
  case 443: flag=_wrap_SpatialMotionVectorBase_setAngularVec3(resc,resv,argc,(mxArray**)(argv)); break;
  case 444: flag=_wrap_SpatialMotionVectorBase_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 445: flag=_wrap_SpatialMotionVectorBase_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 446: flag=_wrap_SpatialMotionVectorBase_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 447: flag=_wrap_SpatialMotionVectorBase_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 448: flag=_wrap_SpatialMotionVectorBase_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 449: flag=_wrap_SpatialMotionVectorBase_changePoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 450: flag=_wrap_SpatialMotionVectorBase_changeCoordFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 451: flag=_wrap_SpatialMotionVectorBase_compose(resc,resv,argc,(mxArray**)(argv)); break;
  case 452: flag=_wrap_SpatialMotionVectorBase_inverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 453: flag=_wrap_SpatialMotionVectorBase_dot(resc,resv,argc,(mxArray**)(argv)); break;
  case 454: flag=_wrap_SpatialMotionVectorBase_plus(resc,resv,argc,(mxArray**)(argv)); break;
  case 455: flag=_wrap_SpatialMotionVectorBase_minus(resc,resv,argc,(mxArray**)(argv)); break;
  case 456: flag=_wrap_SpatialMotionVectorBase_uminus(resc,resv,argc,(mxArray**)(argv)); break;
  case 457: flag=_wrap_SpatialMotionVectorBase_Zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 458: flag=_wrap_SpatialMotionVectorBase_asVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 459: flag=_wrap_SpatialMotionVectorBase_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 460: flag=_wrap_SpatialMotionVectorBase_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 461: flag=_wrap_SpatialMotionVectorBase_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 462: flag=_wrap_SpatialMotionVectorBase_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 463: flag=_wrap_delete_SpatialMotionVectorBase(resc,resv,argc,(mxArray**)(argv)); break;
  case 464: flag=_wrap_new_SpatialForceVectorBase(resc,resv,argc,(mxArray**)(argv)); break;
  case 465: flag=_wrap_SpatialForceVectorBase_getLinearVec3(resc,resv,argc,(mxArray**)(argv)); break;
  case 466: flag=_wrap_SpatialForceVectorBase_getAngularVec3(resc,resv,argc,(mxArray**)(argv)); break;
  case 467: flag=_wrap_SpatialForceVectorBase_setLinearVec3(resc,resv,argc,(mxArray**)(argv)); break;
  case 468: flag=_wrap_SpatialForceVectorBase_setAngularVec3(resc,resv,argc,(mxArray**)(argv)); break;
  case 469: flag=_wrap_SpatialForceVectorBase_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 470: flag=_wrap_SpatialForceVectorBase_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 471: flag=_wrap_SpatialForceVectorBase_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 472: flag=_wrap_SpatialForceVectorBase_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 473: flag=_wrap_SpatialForceVectorBase_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 474: flag=_wrap_SpatialForceVectorBase_changePoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 475: flag=_wrap_SpatialForceVectorBase_changeCoordFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 476: flag=_wrap_SpatialForceVectorBase_compose(resc,resv,argc,(mxArray**)(argv)); break;
  case 477: flag=_wrap_SpatialForceVectorBase_inverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 478: flag=_wrap_SpatialForceVectorBase_dot(resc,resv,argc,(mxArray**)(argv)); break;
  case 479: flag=_wrap_SpatialForceVectorBase_plus(resc,resv,argc,(mxArray**)(argv)); break;
  case 480: flag=_wrap_SpatialForceVectorBase_minus(resc,resv,argc,(mxArray**)(argv)); break;
  case 481: flag=_wrap_SpatialForceVectorBase_uminus(resc,resv,argc,(mxArray**)(argv)); break;
  case 482: flag=_wrap_SpatialForceVectorBase_Zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 483: flag=_wrap_SpatialForceVectorBase_asVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 484: flag=_wrap_SpatialForceVectorBase_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 485: flag=_wrap_SpatialForceVectorBase_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 486: flag=_wrap_SpatialForceVectorBase_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 487: flag=_wrap_SpatialForceVectorBase_fromMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 488: flag=_wrap_delete_SpatialForceVectorBase(resc,resv,argc,(mxArray**)(argv)); break;
  case 489: flag=_wrap_new_Dummy(resc,resv,argc,(mxArray**)(argv)); break;
  case 490: flag=_wrap_delete_Dummy(resc,resv,argc,(mxArray**)(argv)); break;
  case 491: flag=_wrap_new_SpatialMotionVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 492: flag=_wrap_SpatialMotionVector_mtimes(resc,resv,argc,(mxArray**)(argv)); break;
  case 493: flag=_wrap_SpatialMotionVector_cross(resc,resv,argc,(mxArray**)(argv)); break;
  case 494: flag=_wrap_SpatialMotionVector_asCrossProductMatrix(resc,resv,argc,(mxArray**)(argv)); break;
  case 495: flag=_wrap_SpatialMotionVector_asCrossProductMatrixWrench(resc,resv,argc,(mxArray**)(argv)); break;
  case 496: flag=_wrap_SpatialMotionVector_exp(resc,resv,argc,(mxArray**)(argv)); break;
  case 497: flag=_wrap_delete_SpatialMotionVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 498: flag=_wrap_new_SpatialForceVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 499: flag=_wrap_delete_SpatialForceVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 500: flag=_wrap_SpatialForceVector_mtimes(resc,resv,argc,(mxArray**)(argv)); break;
  case 501: flag=_wrap_new_Twist(resc,resv,argc,(mxArray**)(argv)); break;
  case 502: flag=_wrap_Twist_plus(resc,resv,argc,(mxArray**)(argv)); break;
  case 503: flag=_wrap_Twist_minus(resc,resv,argc,(mxArray**)(argv)); break;
  case 504: flag=_wrap_Twist_uminus(resc,resv,argc,(mxArray**)(argv)); break;
  case 505: flag=_wrap_Twist_mtimes(resc,resv,argc,(mxArray**)(argv)); break;
  case 506: flag=_wrap_delete_Twist(resc,resv,argc,(mxArray**)(argv)); break;
  case 507: flag=_wrap_new_Wrench(resc,resv,argc,(mxArray**)(argv)); break;
  case 508: flag=_wrap_Wrench_plus(resc,resv,argc,(mxArray**)(argv)); break;
  case 509: flag=_wrap_Wrench_minus(resc,resv,argc,(mxArray**)(argv)); break;
  case 510: flag=_wrap_Wrench_uminus(resc,resv,argc,(mxArray**)(argv)); break;
  case 511: flag=_wrap_delete_Wrench(resc,resv,argc,(mxArray**)(argv)); break;
  case 512: flag=_wrap_new_SpatialMomentum(resc,resv,argc,(mxArray**)(argv)); break;
  case 513: flag=_wrap_SpatialMomentum_plus(resc,resv,argc,(mxArray**)(argv)); break;
  case 514: flag=_wrap_SpatialMomentum_minus(resc,resv,argc,(mxArray**)(argv)); break;
  case 515: flag=_wrap_SpatialMomentum_uminus(resc,resv,argc,(mxArray**)(argv)); break;
  case 516: flag=_wrap_delete_SpatialMomentum(resc,resv,argc,(mxArray**)(argv)); break;
  case 517: flag=_wrap_new_SpatialAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 518: flag=_wrap_SpatialAcc_plus(resc,resv,argc,(mxArray**)(argv)); break;
  case 519: flag=_wrap_SpatialAcc_minus(resc,resv,argc,(mxArray**)(argv)); break;
  case 520: flag=_wrap_SpatialAcc_uminus(resc,resv,argc,(mxArray**)(argv)); break;
  case 521: flag=_wrap_delete_SpatialAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 522: flag=_wrap_new_ClassicalAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 523: flag=_wrap_ClassicalAcc_changeCoordFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 524: flag=_wrap_ClassicalAcc_Zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 525: flag=_wrap_ClassicalAcc_fromSpatial(resc,resv,argc,(mxArray**)(argv)); break;
  case 526: flag=_wrap_ClassicalAcc_toSpatial(resc,resv,argc,(mxArray**)(argv)); break;
  case 527: flag=_wrap_delete_ClassicalAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 528: flag=_wrap_new_Direction(resc,resv,argc,(mxArray**)(argv)); break;
  case 529: flag=_wrap_Direction_Normalize(resc,resv,argc,(mxArray**)(argv)); break;
  case 530: flag=_wrap_Direction_isParallel(resc,resv,argc,(mxArray**)(argv)); break;
  case 531: flag=_wrap_Direction_isPerpendicular(resc,resv,argc,(mxArray**)(argv)); break;
  case 532: flag=_wrap_Direction_reverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 533: flag=_wrap_Direction_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 534: flag=_wrap_Direction_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 535: flag=_wrap_Direction_Default(resc,resv,argc,(mxArray**)(argv)); break;
  case 536: flag=_wrap_delete_Direction(resc,resv,argc,(mxArray**)(argv)); break;
  case 537: flag=_wrap_new_Axis(resc,resv,argc,(mxArray**)(argv)); break;
  case 538: flag=_wrap_Axis_getDirection(resc,resv,argc,(mxArray**)(argv)); break;
  case 539: flag=_wrap_Axis_getOrigin(resc,resv,argc,(mxArray**)(argv)); break;
  case 540: flag=_wrap_Axis_setDirection(resc,resv,argc,(mxArray**)(argv)); break;
  case 541: flag=_wrap_Axis_setOrigin(resc,resv,argc,(mxArray**)(argv)); break;
  case 542: flag=_wrap_Axis_getRotationTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 543: flag=_wrap_Axis_getRotationTransformDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 544: flag=_wrap_Axis_getRotationTwist(resc,resv,argc,(mxArray**)(argv)); break;
  case 545: flag=_wrap_Axis_getRotationSpatialAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 546: flag=_wrap_Axis_getTranslationTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 547: flag=_wrap_Axis_getTranslationTransformDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 548: flag=_wrap_Axis_getTranslationTwist(resc,resv,argc,(mxArray**)(argv)); break;
  case 549: flag=_wrap_Axis_getTranslationSpatialAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 550: flag=_wrap_Axis_isParallel(resc,resv,argc,(mxArray**)(argv)); break;
  case 551: flag=_wrap_Axis_reverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 552: flag=_wrap_Axis_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 553: flag=_wrap_Axis_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 554: flag=_wrap_delete_Axis(resc,resv,argc,(mxArray**)(argv)); break;
  case 555: flag=_wrap_new_RotationalInertiaRaw(resc,resv,argc,(mxArray**)(argv)); break;
  case 556: flag=_wrap_RotationalInertiaRaw_Zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 557: flag=_wrap_delete_RotationalInertiaRaw(resc,resv,argc,(mxArray**)(argv)); break;
  case 558: flag=_wrap_new_SpatialInertiaRaw(resc,resv,argc,(mxArray**)(argv)); break;
  case 559: flag=_wrap_SpatialInertiaRaw_fromRotationalInertiaWrtCenterOfMass(resc,resv,argc,(mxArray**)(argv)); break;
  case 560: flag=_wrap_SpatialInertiaRaw_getMass(resc,resv,argc,(mxArray**)(argv)); break;
  case 561: flag=_wrap_SpatialInertiaRaw_getCenterOfMass(resc,resv,argc,(mxArray**)(argv)); break;
  case 562: flag=_wrap_SpatialInertiaRaw_getRotationalInertiaWrtFrameOrigin(resc,resv,argc,(mxArray**)(argv)); break;
  case 563: flag=_wrap_SpatialInertiaRaw_getRotationalInertiaWrtCenterOfMass(resc,resv,argc,(mxArray**)(argv)); break;
  case 564: flag=_wrap_SpatialInertiaRaw_combine(resc,resv,argc,(mxArray**)(argv)); break;
  case 565: flag=_wrap_SpatialInertiaRaw_multiply(resc,resv,argc,(mxArray**)(argv)); break;
  case 566: flag=_wrap_SpatialInertiaRaw_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 567: flag=_wrap_delete_SpatialInertiaRaw(resc,resv,argc,(mxArray**)(argv)); break;
  case 568: flag=_wrap_new_SpatialInertia(resc,resv,argc,(mxArray**)(argv)); break;
  case 569: flag=_wrap_SpatialInertia_combine(resc,resv,argc,(mxArray**)(argv)); break;
  case 570: flag=_wrap_SpatialInertia_asMatrix(resc,resv,argc,(mxArray**)(argv)); break;
  case 571: flag=_wrap_SpatialInertia_applyInverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 572: flag=_wrap_SpatialInertia_getInverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 573: flag=_wrap_SpatialInertia_plus(resc,resv,argc,(mxArray**)(argv)); break;
  case 574: flag=_wrap_SpatialInertia_mtimes(resc,resv,argc,(mxArray**)(argv)); break;
  case 575: flag=_wrap_SpatialInertia_biasWrench(resc,resv,argc,(mxArray**)(argv)); break;
  case 576: flag=_wrap_SpatialInertia_biasWrenchDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 577: flag=_wrap_SpatialInertia_Zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 578: flag=_wrap_SpatialInertia_asVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 579: flag=_wrap_SpatialInertia_fromVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 580: flag=_wrap_SpatialInertia_isPhysicallyConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 581: flag=_wrap_SpatialInertia_momentumRegressor(resc,resv,argc,(mxArray**)(argv)); break;
  case 582: flag=_wrap_SpatialInertia_momentumDerivativeRegressor(resc,resv,argc,(mxArray**)(argv)); break;
  case 583: flag=_wrap_SpatialInertia_momentumDerivativeSlotineLiRegressor(resc,resv,argc,(mxArray**)(argv)); break;
  case 584: flag=_wrap_delete_SpatialInertia(resc,resv,argc,(mxArray**)(argv)); break;
  case 585: flag=_wrap_new_ArticulatedBodyInertia(resc,resv,argc,(mxArray**)(argv)); break;
  case 586: flag=_wrap_ArticulatedBodyInertia_getLinearLinearSubmatrix(resc,resv,argc,(mxArray**)(argv)); break;
  case 587: flag=_wrap_ArticulatedBodyInertia_getLinearAngularSubmatrix(resc,resv,argc,(mxArray**)(argv)); break;
  case 588: flag=_wrap_ArticulatedBodyInertia_getAngularAngularSubmatrix(resc,resv,argc,(mxArray**)(argv)); break;
  case 589: flag=_wrap_ArticulatedBodyInertia_combine(resc,resv,argc,(mxArray**)(argv)); break;
  case 590: flag=_wrap_ArticulatedBodyInertia_applyInverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 591: flag=_wrap_ArticulatedBodyInertia_asMatrix(resc,resv,argc,(mxArray**)(argv)); break;
  case 592: flag=_wrap_ArticulatedBodyInertia_getInverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 593: flag=_wrap_ArticulatedBodyInertia_plus(resc,resv,argc,(mxArray**)(argv)); break;
  case 594: flag=_wrap_ArticulatedBodyInertia_minus(resc,resv,argc,(mxArray**)(argv)); break;
  case 595: flag=_wrap_ArticulatedBodyInertia_mtimes(resc,resv,argc,(mxArray**)(argv)); break;
  case 596: flag=_wrap_ArticulatedBodyInertia_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 597: flag=_wrap_ArticulatedBodyInertia_ABADyadHelper(resc,resv,argc,(mxArray**)(argv)); break;
  case 598: flag=_wrap_ArticulatedBodyInertia_ABADyadHelperLin(resc,resv,argc,(mxArray**)(argv)); break;
  case 599: flag=_wrap_delete_ArticulatedBodyInertia(resc,resv,argc,(mxArray**)(argv)); break;
  case 600: flag=_wrap_RigidBodyInertiaNonLinearParametrization_mass_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 601: flag=_wrap_RigidBodyInertiaNonLinearParametrization_mass_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 602: flag=_wrap_RigidBodyInertiaNonLinearParametrization_com_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 603: flag=_wrap_RigidBodyInertiaNonLinearParametrization_com_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 604: flag=_wrap_RigidBodyInertiaNonLinearParametrization_link_R_centroidal_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 605: flag=_wrap_RigidBodyInertiaNonLinearParametrization_link_R_centroidal_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 606: flag=_wrap_RigidBodyInertiaNonLinearParametrization_centralSecondMomentOfMass_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 607: flag=_wrap_RigidBodyInertiaNonLinearParametrization_centralSecondMomentOfMass_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 608: flag=_wrap_RigidBodyInertiaNonLinearParametrization_getLinkCentroidalTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 609: flag=_wrap_RigidBodyInertiaNonLinearParametrization_fromRigidBodyInertia(resc,resv,argc,(mxArray**)(argv)); break;
  case 610: flag=_wrap_RigidBodyInertiaNonLinearParametrization_fromInertialParameters(resc,resv,argc,(mxArray**)(argv)); break;
  case 611: flag=_wrap_RigidBodyInertiaNonLinearParametrization_toRigidBodyInertia(resc,resv,argc,(mxArray**)(argv)); break;
  case 612: flag=_wrap_RigidBodyInertiaNonLinearParametrization_isPhysicallyConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 613: flag=_wrap_RigidBodyInertiaNonLinearParametrization_asVectorWithRotationAsVec(resc,resv,argc,(mxArray**)(argv)); break;
  case 614: flag=_wrap_RigidBodyInertiaNonLinearParametrization_fromVectorWithRotationAsVec(resc,resv,argc,(mxArray**)(argv)); break;
  case 615: flag=_wrap_RigidBodyInertiaNonLinearParametrization_getGradientWithRotationAsVec(resc,resv,argc,(mxArray**)(argv)); break;
  case 616: flag=_wrap_new_RigidBodyInertiaNonLinearParametrization(resc,resv,argc,(mxArray**)(argv)); break;
  case 617: flag=_wrap_delete_RigidBodyInertiaNonLinearParametrization(resc,resv,argc,(mxArray**)(argv)); break;
  case 618: flag=_wrap_new_RotationRaw(resc,resv,argc,(mxArray**)(argv)); break;
  case 619: flag=_wrap_RotationRaw_changeOrientFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 620: flag=_wrap_RotationRaw_changeRefOrientFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 621: flag=_wrap_RotationRaw_compose(resc,resv,argc,(mxArray**)(argv)); break;
  case 622: flag=_wrap_RotationRaw_inverse2(resc,resv,argc,(mxArray**)(argv)); break;
  case 623: flag=_wrap_RotationRaw_changeCoordFrameOf(resc,resv,argc,(mxArray**)(argv)); break;
  case 624: flag=_wrap_RotationRaw_RotX(resc,resv,argc,(mxArray**)(argv)); break;
  case 625: flag=_wrap_RotationRaw_RotY(resc,resv,argc,(mxArray**)(argv)); break;
  case 626: flag=_wrap_RotationRaw_RotZ(resc,resv,argc,(mxArray**)(argv)); break;
  case 627: flag=_wrap_RotationRaw_RPY(resc,resv,argc,(mxArray**)(argv)); break;
  case 628: flag=_wrap_RotationRaw_Identity(resc,resv,argc,(mxArray**)(argv)); break;
  case 629: flag=_wrap_RotationRaw_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 630: flag=_wrap_RotationRaw_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 631: flag=_wrap_delete_RotationRaw(resc,resv,argc,(mxArray**)(argv)); break;
  case 632: flag=_wrap_new_Rotation(resc,resv,argc,(mxArray**)(argv)); break;
  case 633: flag=_wrap_Rotation_changeOrientFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 634: flag=_wrap_Rotation_changeRefOrientFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 635: flag=_wrap_Rotation_changeCoordinateFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 636: flag=_wrap_Rotation_compose(resc,resv,argc,(mxArray**)(argv)); break;
  case 637: flag=_wrap_Rotation_inverse2(resc,resv,argc,(mxArray**)(argv)); break;
  case 638: flag=_wrap_Rotation_changeCoordFrameOf(resc,resv,argc,(mxArray**)(argv)); break;
  case 639: flag=_wrap_Rotation_inverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 640: flag=_wrap_Rotation_mtimes(resc,resv,argc,(mxArray**)(argv)); break;
  case 641: flag=_wrap_Rotation_log(resc,resv,argc,(mxArray**)(argv)); break;
  case 642: flag=_wrap_Rotation_fromQuaternion(resc,resv,argc,(mxArray**)(argv)); break;
  case 643: flag=_wrap_Rotation_getRPY(resc,resv,argc,(mxArray**)(argv)); break;
  case 644: flag=_wrap_Rotation_asRPY(resc,resv,argc,(mxArray**)(argv)); break;
  case 645: flag=_wrap_Rotation_getQuaternion(resc,resv,argc,(mxArray**)(argv)); break;
  case 646: flag=_wrap_Rotation_asQuaternion(resc,resv,argc,(mxArray**)(argv)); break;
  case 647: flag=_wrap_Rotation_RotX(resc,resv,argc,(mxArray**)(argv)); break;
  case 648: flag=_wrap_Rotation_RotY(resc,resv,argc,(mxArray**)(argv)); break;
  case 649: flag=_wrap_Rotation_RotZ(resc,resv,argc,(mxArray**)(argv)); break;
  case 650: flag=_wrap_Rotation_RotAxis(resc,resv,argc,(mxArray**)(argv)); break;
  case 651: flag=_wrap_Rotation_RotAxisDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 652: flag=_wrap_Rotation_RPY(resc,resv,argc,(mxArray**)(argv)); break;
  case 653: flag=_wrap_Rotation_RPYRightTrivializedDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 654: flag=_wrap_Rotation_RPYRightTrivializedDerivativeRateOfChange(resc,resv,argc,(mxArray**)(argv)); break;
  case 655: flag=_wrap_Rotation_RPYRightTrivializedDerivativeInverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 656: flag=_wrap_Rotation_RPYRightTrivializedDerivativeInverseRateOfChange(resc,resv,argc,(mxArray**)(argv)); break;
  case 657: flag=_wrap_Rotation_QuaternionRightTrivializedDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 658: flag=_wrap_Rotation_QuaternionRightTrivializedDerivativeInverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 659: flag=_wrap_Rotation_Identity(resc,resv,argc,(mxArray**)(argv)); break;
  case 660: flag=_wrap_Rotation_RotationFromQuaternion(resc,resv,argc,(mxArray**)(argv)); break;
  case 661: flag=_wrap_Rotation_leftJacobian(resc,resv,argc,(mxArray**)(argv)); break;
  case 662: flag=_wrap_Rotation_leftJacobianInverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 663: flag=_wrap_Rotation_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 664: flag=_wrap_Rotation_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 665: flag=_wrap_delete_Rotation(resc,resv,argc,(mxArray**)(argv)); break;
  case 666: flag=_wrap_new_Transform(resc,resv,argc,(mxArray**)(argv)); break;
  case 667: flag=_wrap_Transform_fromHomogeneousTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 668: flag=_wrap_Transform_getRotation(resc,resv,argc,(mxArray**)(argv)); break;
  case 669: flag=_wrap_Transform_getPosition(resc,resv,argc,(mxArray**)(argv)); break;
  case 670: flag=_wrap_Transform_setRotation(resc,resv,argc,(mxArray**)(argv)); break;
  case 671: flag=_wrap_Transform_setPosition(resc,resv,argc,(mxArray**)(argv)); break;
  case 672: flag=_wrap_Transform_compose(resc,resv,argc,(mxArray**)(argv)); break;
  case 673: flag=_wrap_Transform_inverse2(resc,resv,argc,(mxArray**)(argv)); break;
  case 674: flag=_wrap_Transform_inverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 675: flag=_wrap_Transform_mtimes(resc,resv,argc,(mxArray**)(argv)); break;
  case 676: flag=_wrap_Transform_Identity(resc,resv,argc,(mxArray**)(argv)); break;
  case 677: flag=_wrap_Transform_asHomogeneousTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 678: flag=_wrap_Transform_asAdjointTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 679: flag=_wrap_Transform_asAdjointTransformWrench(resc,resv,argc,(mxArray**)(argv)); break;
  case 680: flag=_wrap_Transform_log(resc,resv,argc,(mxArray**)(argv)); break;
  case 681: flag=_wrap_Transform_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 682: flag=_wrap_Transform_display(resc,resv,argc,(mxArray**)(argv)); break;
  case 683: flag=_wrap_delete_Transform(resc,resv,argc,(mxArray**)(argv)); break;
  case 684: flag=_wrap_new_TransformDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 685: flag=_wrap_delete_TransformDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 686: flag=_wrap_TransformDerivative_getRotationDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 687: flag=_wrap_TransformDerivative_getPositionDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 688: flag=_wrap_TransformDerivative_setRotationDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 689: flag=_wrap_TransformDerivative_setPositionDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 690: flag=_wrap_TransformDerivative_Zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 691: flag=_wrap_TransformDerivative_asHomogeneousTransformDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 692: flag=_wrap_TransformDerivative_asAdjointTransformDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 693: flag=_wrap_TransformDerivative_asAdjointTransformWrenchDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 694: flag=_wrap_TransformDerivative_mtimes(resc,resv,argc,(mxArray**)(argv)); break;
  case 695: flag=_wrap_TransformDerivative_derivativeOfInverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 696: flag=_wrap_TransformDerivative_transform(resc,resv,argc,(mxArray**)(argv)); break;
  case 697: flag=_wrap_dynamic_extent_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 698: flag=_wrap_DynamicSpan_extent_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 699: flag=_wrap_new_DynamicSpan(resc,resv,argc,(mxArray**)(argv)); break;
  case 700: flag=_wrap_delete_DynamicSpan(resc,resv,argc,(mxArray**)(argv)); break;
  case 701: flag=_wrap_DynamicSpan_first(resc,resv,argc,(mxArray**)(argv)); break;
  case 702: flag=_wrap_DynamicSpan_last(resc,resv,argc,(mxArray**)(argv)); break;
  case 703: flag=_wrap_DynamicSpan_subspan(resc,resv,argc,(mxArray**)(argv)); break;
  case 704: flag=_wrap_DynamicSpan_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 705: flag=_wrap_DynamicSpan_size_bytes(resc,resv,argc,(mxArray**)(argv)); break;
  case 706: flag=_wrap_DynamicSpan_empty(resc,resv,argc,(mxArray**)(argv)); break;
  case 707: flag=_wrap_DynamicSpan_brace(resc,resv,argc,(mxArray**)(argv)); break;
  case 708: flag=_wrap_DynamicSpan_getVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 709: flag=_wrap_DynamicSpan_setVal(resc,resv,argc,(mxArray**)(argv)); break;
  case 710: flag=_wrap_DynamicSpan_at(resc,resv,argc,(mxArray**)(argv)); break;
  case 711: flag=_wrap_DynamicSpan_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 712: flag=_wrap_DynamicSpan_begin(resc,resv,argc,(mxArray**)(argv)); break;
  case 713: flag=_wrap_DynamicSpan_end(resc,resv,argc,(mxArray**)(argv)); break;
  case 714: flag=_wrap_DynamicSpan_cbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 715: flag=_wrap_DynamicSpan_cend(resc,resv,argc,(mxArray**)(argv)); break;
  case 716: flag=_wrap_DynamicSpan_rbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 717: flag=_wrap_DynamicSpan_rend(resc,resv,argc,(mxArray**)(argv)); break;
  case 718: flag=_wrap_DynamicSpan_crbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 719: flag=_wrap_DynamicSpan_crend(resc,resv,argc,(mxArray**)(argv)); break;
  case 720: flag=_wrap_new_DynamicMatrixView(resc,resv,argc,(mxArray**)(argv)); break;
  case 721: flag=_wrap_DynamicMatrixView_storageOrder(resc,resv,argc,(mxArray**)(argv)); break;
  case 722: flag=_wrap_DynamicMatrixView_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 723: flag=_wrap_DynamicMatrixView_rows(resc,resv,argc,(mxArray**)(argv)); break;
  case 724: flag=_wrap_DynamicMatrixView_cols(resc,resv,argc,(mxArray**)(argv)); break;
  case 725: flag=_wrap_DynamicMatrixView_block(resc,resv,argc,(mxArray**)(argv)); break;
  case 726: flag=_wrap_delete_DynamicMatrixView(resc,resv,argc,(mxArray**)(argv)); break;
  case 727: flag=_wrap_LINK_INVALID_INDEX_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 728: flag=_wrap_LINK_INVALID_INDEX_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 729: flag=_wrap_LINK_INVALID_NAME_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 730: flag=_wrap_LINK_INVALID_NAME_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 731: flag=_wrap_JOINT_INVALID_INDEX_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 732: flag=_wrap_JOINT_INVALID_INDEX_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 733: flag=_wrap_JOINT_INVALID_NAME_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 734: flag=_wrap_JOINT_INVALID_NAME_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 735: flag=_wrap_DOF_INVALID_INDEX_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 736: flag=_wrap_DOF_INVALID_INDEX_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 737: flag=_wrap_DOF_INVALID_NAME_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 738: flag=_wrap_DOF_INVALID_NAME_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 739: flag=_wrap_FRAME_INVALID_INDEX_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 740: flag=_wrap_FRAME_INVALID_INDEX_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 741: flag=_wrap_FRAME_INVALID_NAME_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 742: flag=_wrap_FRAME_INVALID_NAME_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 743: flag=_wrap_TRAVERSAL_INVALID_INDEX_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 744: flag=_wrap_TRAVERSAL_INVALID_INDEX_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 745: flag=_wrap_new_LinkPositions(resc,resv,argc,(mxArray**)(argv)); break;
  case 746: flag=_wrap_LinkPositions_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 747: flag=_wrap_LinkPositions_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 748: flag=_wrap_LinkPositions_getNrOfLinks(resc,resv,argc,(mxArray**)(argv)); break;
  case 749: flag=_wrap_LinkPositions_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 750: flag=_wrap_LinkPositions_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 751: flag=_wrap_delete_LinkPositions(resc,resv,argc,(mxArray**)(argv)); break;
  case 752: flag=_wrap_new_LinkWrenches(resc,resv,argc,(mxArray**)(argv)); break;
  case 753: flag=_wrap_LinkWrenches_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 754: flag=_wrap_LinkWrenches_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 755: flag=_wrap_LinkWrenches_getNrOfLinks(resc,resv,argc,(mxArray**)(argv)); break;
  case 756: flag=_wrap_LinkWrenches_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 757: flag=_wrap_LinkWrenches_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 758: flag=_wrap_LinkWrenches_zero(resc,resv,argc,(mxArray**)(argv)); break;
  case 759: flag=_wrap_delete_LinkWrenches(resc,resv,argc,(mxArray**)(argv)); break;
  case 760: flag=_wrap_new_LinkInertias(resc,resv,argc,(mxArray**)(argv)); break;
  case 761: flag=_wrap_LinkInertias_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 762: flag=_wrap_LinkInertias_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 763: flag=_wrap_LinkInertias_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 764: flag=_wrap_delete_LinkInertias(resc,resv,argc,(mxArray**)(argv)); break;
  case 765: flag=_wrap_new_LinkArticulatedBodyInertias(resc,resv,argc,(mxArray**)(argv)); break;
  case 766: flag=_wrap_LinkArticulatedBodyInertias_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 767: flag=_wrap_LinkArticulatedBodyInertias_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 768: flag=_wrap_LinkArticulatedBodyInertias_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 769: flag=_wrap_delete_LinkArticulatedBodyInertias(resc,resv,argc,(mxArray**)(argv)); break;
  case 770: flag=_wrap_new_LinkVelArray(resc,resv,argc,(mxArray**)(argv)); break;
  case 771: flag=_wrap_LinkVelArray_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 772: flag=_wrap_LinkVelArray_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 773: flag=_wrap_LinkVelArray_getNrOfLinks(resc,resv,argc,(mxArray**)(argv)); break;
  case 774: flag=_wrap_LinkVelArray_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 775: flag=_wrap_LinkVelArray_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 776: flag=_wrap_delete_LinkVelArray(resc,resv,argc,(mxArray**)(argv)); break;
  case 777: flag=_wrap_new_LinkAccArray(resc,resv,argc,(mxArray**)(argv)); break;
  case 778: flag=_wrap_LinkAccArray_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 779: flag=_wrap_LinkAccArray_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 780: flag=_wrap_LinkAccArray_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 781: flag=_wrap_LinkAccArray_getNrOfLinks(resc,resv,argc,(mxArray**)(argv)); break;
  case 782: flag=_wrap_LinkAccArray_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 783: flag=_wrap_delete_LinkAccArray(resc,resv,argc,(mxArray**)(argv)); break;
  case 784: flag=_wrap_new_Link(resc,resv,argc,(mxArray**)(argv)); break;
  case 785: flag=_wrap_Link_inertia(resc,resv,argc,(mxArray**)(argv)); break;
  case 786: flag=_wrap_Link_setInertia(resc,resv,argc,(mxArray**)(argv)); break;
  case 787: flag=_wrap_Link_getInertia(resc,resv,argc,(mxArray**)(argv)); break;
  case 788: flag=_wrap_Link_setIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 789: flag=_wrap_Link_getIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 790: flag=_wrap_delete_Link(resc,resv,argc,(mxArray**)(argv)); break;
  case 791: flag=_wrap_delete_IJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 792: flag=_wrap_IJoint_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 793: flag=_wrap_IJoint_getNrOfPosCoords(resc,resv,argc,(mxArray**)(argv)); break;
  case 794: flag=_wrap_IJoint_getNrOfDOFs(resc,resv,argc,(mxArray**)(argv)); break;
  case 795: flag=_wrap_IJoint_setAttachedLinks(resc,resv,argc,(mxArray**)(argv)); break;
  case 796: flag=_wrap_IJoint_setRestTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 797: flag=_wrap_IJoint_getFirstAttachedLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 798: flag=_wrap_IJoint_getSecondAttachedLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 799: flag=_wrap_IJoint_getRestTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 800: flag=_wrap_IJoint_getTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 801: flag=_wrap_IJoint_getTransformDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 802: flag=_wrap_IJoint_getMotionSubspaceVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 803: flag=_wrap_IJoint_computeChildPosVelAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 804: flag=_wrap_IJoint_computeChildVelAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 805: flag=_wrap_IJoint_computeChildVel(resc,resv,argc,(mxArray**)(argv)); break;
  case 806: flag=_wrap_IJoint_computeChildAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 807: flag=_wrap_IJoint_computeChildBiasAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 808: flag=_wrap_IJoint_computeJointTorque(resc,resv,argc,(mxArray**)(argv)); break;
  case 809: flag=_wrap_IJoint_setIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 810: flag=_wrap_IJoint_getIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 811: flag=_wrap_IJoint_setPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 812: flag=_wrap_IJoint_getPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 813: flag=_wrap_IJoint_setDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 814: flag=_wrap_IJoint_getDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 815: flag=_wrap_IJoint_hasPosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 816: flag=_wrap_IJoint_enablePosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 817: flag=_wrap_IJoint_getPosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 818: flag=_wrap_IJoint_getMinPosLimit(resc,resv,argc,(mxArray**)(argv)); break;
  case 819: flag=_wrap_IJoint_getMaxPosLimit(resc,resv,argc,(mxArray**)(argv)); break;
  case 820: flag=_wrap_IJoint_setPosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 821: flag=_wrap_IJoint_isRevoluteJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 822: flag=_wrap_IJoint_isFixedJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 823: flag=_wrap_IJoint_asRevoluteJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 824: flag=_wrap_IJoint_asFixedJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 825: flag=_wrap_new_FixedJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 826: flag=_wrap_delete_FixedJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 827: flag=_wrap_FixedJoint_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 828: flag=_wrap_FixedJoint_getNrOfPosCoords(resc,resv,argc,(mxArray**)(argv)); break;
  case 829: flag=_wrap_FixedJoint_getNrOfDOFs(resc,resv,argc,(mxArray**)(argv)); break;
  case 830: flag=_wrap_FixedJoint_setAttachedLinks(resc,resv,argc,(mxArray**)(argv)); break;
  case 831: flag=_wrap_FixedJoint_setRestTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 832: flag=_wrap_FixedJoint_getFirstAttachedLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 833: flag=_wrap_FixedJoint_getSecondAttachedLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 834: flag=_wrap_FixedJoint_getRestTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 835: flag=_wrap_FixedJoint_getTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 836: flag=_wrap_FixedJoint_getTransformDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 837: flag=_wrap_FixedJoint_getMotionSubspaceVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 838: flag=_wrap_FixedJoint_computeChildPosVelAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 839: flag=_wrap_FixedJoint_computeChildVelAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 840: flag=_wrap_FixedJoint_computeChildVel(resc,resv,argc,(mxArray**)(argv)); break;
  case 841: flag=_wrap_FixedJoint_computeChildAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 842: flag=_wrap_FixedJoint_computeChildBiasAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 843: flag=_wrap_FixedJoint_computeJointTorque(resc,resv,argc,(mxArray**)(argv)); break;
  case 844: flag=_wrap_FixedJoint_setIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 845: flag=_wrap_FixedJoint_getIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 846: flag=_wrap_FixedJoint_setPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 847: flag=_wrap_FixedJoint_getPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 848: flag=_wrap_FixedJoint_setDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 849: flag=_wrap_FixedJoint_getDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 850: flag=_wrap_FixedJoint_hasPosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 851: flag=_wrap_FixedJoint_enablePosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 852: flag=_wrap_FixedJoint_getPosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 853: flag=_wrap_FixedJoint_getMinPosLimit(resc,resv,argc,(mxArray**)(argv)); break;
  case 854: flag=_wrap_FixedJoint_getMaxPosLimit(resc,resv,argc,(mxArray**)(argv)); break;
  case 855: flag=_wrap_FixedJoint_setPosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 856: flag=_wrap_delete_MovableJointImpl1(resc,resv,argc,(mxArray**)(argv)); break;
  case 857: flag=_wrap_MovableJointImpl1_getNrOfPosCoords(resc,resv,argc,(mxArray**)(argv)); break;
  case 858: flag=_wrap_MovableJointImpl1_getNrOfDOFs(resc,resv,argc,(mxArray**)(argv)); break;
  case 859: flag=_wrap_MovableJointImpl1_setIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 860: flag=_wrap_MovableJointImpl1_getIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 861: flag=_wrap_MovableJointImpl1_setPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 862: flag=_wrap_MovableJointImpl1_getPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 863: flag=_wrap_MovableJointImpl1_setDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 864: flag=_wrap_MovableJointImpl1_getDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 865: flag=_wrap_delete_MovableJointImpl2(resc,resv,argc,(mxArray**)(argv)); break;
  case 866: flag=_wrap_MovableJointImpl2_getNrOfPosCoords(resc,resv,argc,(mxArray**)(argv)); break;
  case 867: flag=_wrap_MovableJointImpl2_getNrOfDOFs(resc,resv,argc,(mxArray**)(argv)); break;
  case 868: flag=_wrap_MovableJointImpl2_setIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 869: flag=_wrap_MovableJointImpl2_getIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 870: flag=_wrap_MovableJointImpl2_setPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 871: flag=_wrap_MovableJointImpl2_getPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 872: flag=_wrap_MovableJointImpl2_setDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 873: flag=_wrap_MovableJointImpl2_getDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 874: flag=_wrap_delete_MovableJointImpl3(resc,resv,argc,(mxArray**)(argv)); break;
  case 875: flag=_wrap_MovableJointImpl3_getNrOfPosCoords(resc,resv,argc,(mxArray**)(argv)); break;
  case 876: flag=_wrap_MovableJointImpl3_getNrOfDOFs(resc,resv,argc,(mxArray**)(argv)); break;
  case 877: flag=_wrap_MovableJointImpl3_setIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 878: flag=_wrap_MovableJointImpl3_getIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 879: flag=_wrap_MovableJointImpl3_setPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 880: flag=_wrap_MovableJointImpl3_getPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 881: flag=_wrap_MovableJointImpl3_setDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 882: flag=_wrap_MovableJointImpl3_getDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 883: flag=_wrap_delete_MovableJointImpl4(resc,resv,argc,(mxArray**)(argv)); break;
  case 884: flag=_wrap_MovableJointImpl4_getNrOfPosCoords(resc,resv,argc,(mxArray**)(argv)); break;
  case 885: flag=_wrap_MovableJointImpl4_getNrOfDOFs(resc,resv,argc,(mxArray**)(argv)); break;
  case 886: flag=_wrap_MovableJointImpl4_setIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 887: flag=_wrap_MovableJointImpl4_getIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 888: flag=_wrap_MovableJointImpl4_setPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 889: flag=_wrap_MovableJointImpl4_getPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 890: flag=_wrap_MovableJointImpl4_setDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 891: flag=_wrap_MovableJointImpl4_getDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 892: flag=_wrap_delete_MovableJointImpl5(resc,resv,argc,(mxArray**)(argv)); break;
  case 893: flag=_wrap_MovableJointImpl5_getNrOfPosCoords(resc,resv,argc,(mxArray**)(argv)); break;
  case 894: flag=_wrap_MovableJointImpl5_getNrOfDOFs(resc,resv,argc,(mxArray**)(argv)); break;
  case 895: flag=_wrap_MovableJointImpl5_setIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 896: flag=_wrap_MovableJointImpl5_getIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 897: flag=_wrap_MovableJointImpl5_setPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 898: flag=_wrap_MovableJointImpl5_getPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 899: flag=_wrap_MovableJointImpl5_setDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 900: flag=_wrap_MovableJointImpl5_getDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 901: flag=_wrap_delete_MovableJointImpl6(resc,resv,argc,(mxArray**)(argv)); break;
  case 902: flag=_wrap_MovableJointImpl6_getNrOfPosCoords(resc,resv,argc,(mxArray**)(argv)); break;
  case 903: flag=_wrap_MovableJointImpl6_getNrOfDOFs(resc,resv,argc,(mxArray**)(argv)); break;
  case 904: flag=_wrap_MovableJointImpl6_setIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 905: flag=_wrap_MovableJointImpl6_getIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 906: flag=_wrap_MovableJointImpl6_setPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 907: flag=_wrap_MovableJointImpl6_getPosCoordsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 908: flag=_wrap_MovableJointImpl6_setDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 909: flag=_wrap_MovableJointImpl6_getDOFsOffset(resc,resv,argc,(mxArray**)(argv)); break;
  case 910: flag=_wrap_new_RevoluteJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 911: flag=_wrap_delete_RevoluteJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 912: flag=_wrap_RevoluteJoint_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 913: flag=_wrap_RevoluteJoint_setAttachedLinks(resc,resv,argc,(mxArray**)(argv)); break;
  case 914: flag=_wrap_RevoluteJoint_setRestTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 915: flag=_wrap_RevoluteJoint_setAxis(resc,resv,argc,(mxArray**)(argv)); break;
  case 916: flag=_wrap_RevoluteJoint_getFirstAttachedLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 917: flag=_wrap_RevoluteJoint_getSecondAttachedLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 918: flag=_wrap_RevoluteJoint_getAxis(resc,resv,argc,(mxArray**)(argv)); break;
  case 919: flag=_wrap_RevoluteJoint_getRestTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 920: flag=_wrap_RevoluteJoint_getTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 921: flag=_wrap_RevoluteJoint_getTransformDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 922: flag=_wrap_RevoluteJoint_getMotionSubspaceVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 923: flag=_wrap_RevoluteJoint_computeChildPosVelAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 924: flag=_wrap_RevoluteJoint_computeChildVel(resc,resv,argc,(mxArray**)(argv)); break;
  case 925: flag=_wrap_RevoluteJoint_computeChildVelAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 926: flag=_wrap_RevoluteJoint_computeChildAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 927: flag=_wrap_RevoluteJoint_computeChildBiasAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 928: flag=_wrap_RevoluteJoint_computeJointTorque(resc,resv,argc,(mxArray**)(argv)); break;
  case 929: flag=_wrap_RevoluteJoint_hasPosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 930: flag=_wrap_RevoluteJoint_enablePosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 931: flag=_wrap_RevoluteJoint_getPosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 932: flag=_wrap_RevoluteJoint_getMinPosLimit(resc,resv,argc,(mxArray**)(argv)); break;
  case 933: flag=_wrap_RevoluteJoint_getMaxPosLimit(resc,resv,argc,(mxArray**)(argv)); break;
  case 934: flag=_wrap_RevoluteJoint_setPosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 935: flag=_wrap_new_PrismaticJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 936: flag=_wrap_delete_PrismaticJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 937: flag=_wrap_PrismaticJoint_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 938: flag=_wrap_PrismaticJoint_setAttachedLinks(resc,resv,argc,(mxArray**)(argv)); break;
  case 939: flag=_wrap_PrismaticJoint_setRestTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 940: flag=_wrap_PrismaticJoint_setAxis(resc,resv,argc,(mxArray**)(argv)); break;
  case 941: flag=_wrap_PrismaticJoint_getFirstAttachedLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 942: flag=_wrap_PrismaticJoint_getSecondAttachedLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 943: flag=_wrap_PrismaticJoint_getAxis(resc,resv,argc,(mxArray**)(argv)); break;
  case 944: flag=_wrap_PrismaticJoint_getRestTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 945: flag=_wrap_PrismaticJoint_getTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 946: flag=_wrap_PrismaticJoint_getTransformDerivative(resc,resv,argc,(mxArray**)(argv)); break;
  case 947: flag=_wrap_PrismaticJoint_getMotionSubspaceVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 948: flag=_wrap_PrismaticJoint_computeChildPosVelAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 949: flag=_wrap_PrismaticJoint_computeChildVel(resc,resv,argc,(mxArray**)(argv)); break;
  case 950: flag=_wrap_PrismaticJoint_computeChildVelAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 951: flag=_wrap_PrismaticJoint_computeChildAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 952: flag=_wrap_PrismaticJoint_computeChildBiasAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 953: flag=_wrap_PrismaticJoint_computeJointTorque(resc,resv,argc,(mxArray**)(argv)); break;
  case 954: flag=_wrap_PrismaticJoint_hasPosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 955: flag=_wrap_PrismaticJoint_enablePosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 956: flag=_wrap_PrismaticJoint_getPosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 957: flag=_wrap_PrismaticJoint_getMinPosLimit(resc,resv,argc,(mxArray**)(argv)); break;
  case 958: flag=_wrap_PrismaticJoint_getMaxPosLimit(resc,resv,argc,(mxArray**)(argv)); break;
  case 959: flag=_wrap_PrismaticJoint_setPosLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 960: flag=_wrap_new_Traversal(resc,resv,argc,(mxArray**)(argv)); break;
  case 961: flag=_wrap_delete_Traversal(resc,resv,argc,(mxArray**)(argv)); break;
  case 962: flag=_wrap_Traversal_getNrOfVisitedLinks(resc,resv,argc,(mxArray**)(argv)); break;
  case 963: flag=_wrap_Traversal_getLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 964: flag=_wrap_Traversal_getBaseLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 965: flag=_wrap_Traversal_getParentLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 966: flag=_wrap_Traversal_getParentJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 967: flag=_wrap_Traversal_getParentLinkFromLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 968: flag=_wrap_Traversal_getParentJointFromLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 969: flag=_wrap_Traversal_getTraversalIndexFromLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 970: flag=_wrap_Traversal_reset(resc,resv,argc,(mxArray**)(argv)); break;
  case 971: flag=_wrap_Traversal_addTraversalBase(resc,resv,argc,(mxArray**)(argv)); break;
  case 972: flag=_wrap_Traversal_addTraversalElement(resc,resv,argc,(mxArray**)(argv)); break;
  case 973: flag=_wrap_Traversal_isParentOf(resc,resv,argc,(mxArray**)(argv)); break;
  case 974: flag=_wrap_Traversal_getChildLinkIndexFromJointIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 975: flag=_wrap_Traversal_getParentLinkIndexFromJointIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 976: flag=_wrap_Traversal_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 977: flag=_wrap_new_Material(resc,resv,argc,(mxArray**)(argv)); break;
  case 978: flag=_wrap_Material_name(resc,resv,argc,(mxArray**)(argv)); break;
  case 979: flag=_wrap_Material_hasColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 980: flag=_wrap_Material_color(resc,resv,argc,(mxArray**)(argv)); break;
  case 981: flag=_wrap_Material_setColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 982: flag=_wrap_Material_hasTexture(resc,resv,argc,(mxArray**)(argv)); break;
  case 983: flag=_wrap_Material_texture(resc,resv,argc,(mxArray**)(argv)); break;
  case 984: flag=_wrap_Material_setTexture(resc,resv,argc,(mxArray**)(argv)); break;
  case 985: flag=_wrap_delete_Material(resc,resv,argc,(mxArray**)(argv)); break;
  case 986: flag=_wrap_delete_SolidShape(resc,resv,argc,(mxArray**)(argv)); break;
  case 987: flag=_wrap_SolidShape_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 988: flag=_wrap_SolidShape_getName(resc,resv,argc,(mxArray**)(argv)); break;
  case 989: flag=_wrap_SolidShape_setName(resc,resv,argc,(mxArray**)(argv)); break;
  case 990: flag=_wrap_SolidShape_isNameValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 991: flag=_wrap_SolidShape_getLink_H_geometry(resc,resv,argc,(mxArray**)(argv)); break;
  case 992: flag=_wrap_SolidShape_setLink_H_geometry(resc,resv,argc,(mxArray**)(argv)); break;
  case 993: flag=_wrap_SolidShape_isMaterialSet(resc,resv,argc,(mxArray**)(argv)); break;
  case 994: flag=_wrap_SolidShape_getMaterial(resc,resv,argc,(mxArray**)(argv)); break;
  case 995: flag=_wrap_SolidShape_setMaterial(resc,resv,argc,(mxArray**)(argv)); break;
  case 996: flag=_wrap_SolidShape_isSphere(resc,resv,argc,(mxArray**)(argv)); break;
  case 997: flag=_wrap_SolidShape_isBox(resc,resv,argc,(mxArray**)(argv)); break;
  case 998: flag=_wrap_SolidShape_isCylinder(resc,resv,argc,(mxArray**)(argv)); break;
  case 999: flag=_wrap_SolidShape_isExternalMesh(resc,resv,argc,(mxArray**)(argv)); break;
  case 1000: flag=_wrap_SolidShape_asSphere(resc,resv,argc,(mxArray**)(argv)); break;
  case 1001: flag=_wrap_SolidShape_asBox(resc,resv,argc,(mxArray**)(argv)); break;
  case 1002: flag=_wrap_SolidShape_asCylinder(resc,resv,argc,(mxArray**)(argv)); break;
  case 1003: flag=_wrap_SolidShape_asExternalMesh(resc,resv,argc,(mxArray**)(argv)); break;
  case 1004: flag=_wrap_delete_Sphere(resc,resv,argc,(mxArray**)(argv)); break;
  case 1005: flag=_wrap_Sphere_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 1006: flag=_wrap_Sphere_getRadius(resc,resv,argc,(mxArray**)(argv)); break;
  case 1007: flag=_wrap_Sphere_setRadius(resc,resv,argc,(mxArray**)(argv)); break;
  case 1008: flag=_wrap_new_Sphere(resc,resv,argc,(mxArray**)(argv)); break;
  case 1009: flag=_wrap_delete_Box(resc,resv,argc,(mxArray**)(argv)); break;
  case 1010: flag=_wrap_Box_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 1011: flag=_wrap_Box_getX(resc,resv,argc,(mxArray**)(argv)); break;
  case 1012: flag=_wrap_Box_setX(resc,resv,argc,(mxArray**)(argv)); break;
  case 1013: flag=_wrap_Box_getY(resc,resv,argc,(mxArray**)(argv)); break;
  case 1014: flag=_wrap_Box_setY(resc,resv,argc,(mxArray**)(argv)); break;
  case 1015: flag=_wrap_Box_getZ(resc,resv,argc,(mxArray**)(argv)); break;
  case 1016: flag=_wrap_Box_setZ(resc,resv,argc,(mxArray**)(argv)); break;
  case 1017: flag=_wrap_new_Box(resc,resv,argc,(mxArray**)(argv)); break;
  case 1018: flag=_wrap_delete_Cylinder(resc,resv,argc,(mxArray**)(argv)); break;
  case 1019: flag=_wrap_Cylinder_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 1020: flag=_wrap_Cylinder_getLength(resc,resv,argc,(mxArray**)(argv)); break;
  case 1021: flag=_wrap_Cylinder_setLength(resc,resv,argc,(mxArray**)(argv)); break;
  case 1022: flag=_wrap_Cylinder_getRadius(resc,resv,argc,(mxArray**)(argv)); break;
  case 1023: flag=_wrap_Cylinder_setRadius(resc,resv,argc,(mxArray**)(argv)); break;
  case 1024: flag=_wrap_new_Cylinder(resc,resv,argc,(mxArray**)(argv)); break;
  case 1025: flag=_wrap_delete_ExternalMesh(resc,resv,argc,(mxArray**)(argv)); break;
  case 1026: flag=_wrap_ExternalMesh_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 1027: flag=_wrap_ExternalMesh_getFilename(resc,resv,argc,(mxArray**)(argv)); break;
  case 1028: flag=_wrap_ExternalMesh_getFileLocationOnLocalFileSystem(resc,resv,argc,(mxArray**)(argv)); break;
  case 1029: flag=_wrap_ExternalMesh_setFilename(resc,resv,argc,(mxArray**)(argv)); break;
  case 1030: flag=_wrap_ExternalMesh_getScale(resc,resv,argc,(mxArray**)(argv)); break;
  case 1031: flag=_wrap_ExternalMesh_setScale(resc,resv,argc,(mxArray**)(argv)); break;
  case 1032: flag=_wrap_new_ExternalMesh(resc,resv,argc,(mxArray**)(argv)); break;
  case 1033: flag=_wrap_delete_ModelSolidShapes(resc,resv,argc,(mxArray**)(argv)); break;
  case 1034: flag=_wrap_new_ModelSolidShapes(resc,resv,argc,(mxArray**)(argv)); break;
  case 1035: flag=_wrap_ModelSolidShapes_clear(resc,resv,argc,(mxArray**)(argv)); break;
  case 1036: flag=_wrap_ModelSolidShapes_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1037: flag=_wrap_ModelSolidShapes_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 1038: flag=_wrap_ModelSolidShapes_getLinkSolidShapes(resc,resv,argc,(mxArray**)(argv)); break;
  case 1039: flag=_wrap_Neighbor_neighborLink_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1040: flag=_wrap_Neighbor_neighborLink_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1041: flag=_wrap_Neighbor_neighborJoint_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1042: flag=_wrap_Neighbor_neighborJoint_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1043: flag=_wrap_new_Neighbor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1044: flag=_wrap_delete_Neighbor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1045: flag=_wrap_new_Model(resc,resv,argc,(mxArray**)(argv)); break;
  case 1046: flag=_wrap_Model_copy(resc,resv,argc,(mxArray**)(argv)); break;
  case 1047: flag=_wrap_delete_Model(resc,resv,argc,(mxArray**)(argv)); break;
  case 1048: flag=_wrap_Model_getNrOfLinks(resc,resv,argc,(mxArray**)(argv)); break;
  case 1049: flag=_wrap_Model_getLinkName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1050: flag=_wrap_Model_getLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1051: flag=_wrap_Model_isValidLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1052: flag=_wrap_Model_getLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1053: flag=_wrap_Model_addLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1054: flag=_wrap_Model_getNrOfJoints(resc,resv,argc,(mxArray**)(argv)); break;
  case 1055: flag=_wrap_Model_getJointName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1056: flag=_wrap_Model_getTotalMass(resc,resv,argc,(mxArray**)(argv)); break;
  case 1057: flag=_wrap_Model_getJointIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1058: flag=_wrap_Model_getJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1059: flag=_wrap_Model_isValidJointIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1060: flag=_wrap_Model_isLinkNameUsed(resc,resv,argc,(mxArray**)(argv)); break;
  case 1061: flag=_wrap_Model_isJointNameUsed(resc,resv,argc,(mxArray**)(argv)); break;
  case 1062: flag=_wrap_Model_isFrameNameUsed(resc,resv,argc,(mxArray**)(argv)); break;
  case 1063: flag=_wrap_Model_addJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1064: flag=_wrap_Model_addJointAndLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1065: flag=_wrap_Model_insertLinkToExistingJointAndAddJointForDisplacedLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1066: flag=_wrap_Model_getNrOfPosCoords(resc,resv,argc,(mxArray**)(argv)); break;
  case 1067: flag=_wrap_Model_getNrOfDOFs(resc,resv,argc,(mxArray**)(argv)); break;
  case 1068: flag=_wrap_Model_getNrOfFrames(resc,resv,argc,(mxArray**)(argv)); break;
  case 1069: flag=_wrap_Model_addAdditionalFrameToLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1070: flag=_wrap_Model_getFrameName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1071: flag=_wrap_Model_getFrameIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1072: flag=_wrap_Model_isValidFrameIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1073: flag=_wrap_Model_getFrameTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1074: flag=_wrap_Model_getFrameLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1075: flag=_wrap_Model_getLinkAdditionalFrames(resc,resv,argc,(mxArray**)(argv)); break;
  case 1076: flag=_wrap_Model_getNrOfNeighbors(resc,resv,argc,(mxArray**)(argv)); break;
  case 1077: flag=_wrap_Model_getNeighbor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1078: flag=_wrap_Model_setDefaultBaseLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1079: flag=_wrap_Model_getDefaultBaseLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1080: flag=_wrap_Model_computeFullTreeTraversal(resc,resv,argc,(mxArray**)(argv)); break;
  case 1081: flag=_wrap_Model_getInertialParameters(resc,resv,argc,(mxArray**)(argv)); break;
  case 1082: flag=_wrap_Model_updateInertialParameters(resc,resv,argc,(mxArray**)(argv)); break;
  case 1083: flag=_wrap_Model_visualSolidShapes(resc,resv,argc,(mxArray**)(argv)); break;
  case 1084: flag=_wrap_Model_collisionSolidShapes(resc,resv,argc,(mxArray**)(argv)); break;
  case 1085: flag=_wrap_Model_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 1086: flag=_wrap_new_JointPosDoubleArray(resc,resv,argc,(mxArray**)(argv)); break;
  case 1087: flag=_wrap_JointPosDoubleArray_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1088: flag=_wrap_JointPosDoubleArray_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 1089: flag=_wrap_delete_JointPosDoubleArray(resc,resv,argc,(mxArray**)(argv)); break;
  case 1090: flag=_wrap_new_JointDOFsDoubleArray(resc,resv,argc,(mxArray**)(argv)); break;
  case 1091: flag=_wrap_JointDOFsDoubleArray_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1092: flag=_wrap_JointDOFsDoubleArray_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 1093: flag=_wrap_delete_JointDOFsDoubleArray(resc,resv,argc,(mxArray**)(argv)); break;
  case 1094: flag=_wrap_new_DOFSpatialForceArray(resc,resv,argc,(mxArray**)(argv)); break;
  case 1095: flag=_wrap_DOFSpatialForceArray_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1096: flag=_wrap_DOFSpatialForceArray_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 1097: flag=_wrap_DOFSpatialForceArray_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 1098: flag=_wrap_delete_DOFSpatialForceArray(resc,resv,argc,(mxArray**)(argv)); break;
  case 1099: flag=_wrap_new_DOFSpatialMotionArray(resc,resv,argc,(mxArray**)(argv)); break;
  case 1100: flag=_wrap_DOFSpatialMotionArray_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1101: flag=_wrap_DOFSpatialMotionArray_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 1102: flag=_wrap_DOFSpatialMotionArray_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 1103: flag=_wrap_delete_DOFSpatialMotionArray(resc,resv,argc,(mxArray**)(argv)); break;
  case 1104: flag=_wrap_new_FrameFreeFloatingJacobian(resc,resv,argc,(mxArray**)(argv)); break;
  case 1105: flag=_wrap_FrameFreeFloatingJacobian_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1106: flag=_wrap_FrameFreeFloatingJacobian_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 1107: flag=_wrap_delete_FrameFreeFloatingJacobian(resc,resv,argc,(mxArray**)(argv)); break;
  case 1108: flag=_wrap_new_MomentumFreeFloatingJacobian(resc,resv,argc,(mxArray**)(argv)); break;
  case 1109: flag=_wrap_MomentumFreeFloatingJacobian_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1110: flag=_wrap_MomentumFreeFloatingJacobian_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 1111: flag=_wrap_delete_MomentumFreeFloatingJacobian(resc,resv,argc,(mxArray**)(argv)); break;
  case 1112: flag=_wrap_new_FreeFloatingMassMatrix(resc,resv,argc,(mxArray**)(argv)); break;
  case 1113: flag=_wrap_FreeFloatingMassMatrix_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1114: flag=_wrap_delete_FreeFloatingMassMatrix(resc,resv,argc,(mxArray**)(argv)); break;
  case 1115: flag=_wrap_new_FreeFloatingPos(resc,resv,argc,(mxArray**)(argv)); break;
  case 1116: flag=_wrap_FreeFloatingPos_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1117: flag=_wrap_FreeFloatingPos_worldBasePos(resc,resv,argc,(mxArray**)(argv)); break;
  case 1118: flag=_wrap_FreeFloatingPos_jointPos(resc,resv,argc,(mxArray**)(argv)); break;
  case 1119: flag=_wrap_FreeFloatingPos_getNrOfPosCoords(resc,resv,argc,(mxArray**)(argv)); break;
  case 1120: flag=_wrap_delete_FreeFloatingPos(resc,resv,argc,(mxArray**)(argv)); break;
  case 1121: flag=_wrap_new_FreeFloatingGeneralizedTorques(resc,resv,argc,(mxArray**)(argv)); break;
  case 1122: flag=_wrap_FreeFloatingGeneralizedTorques_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1123: flag=_wrap_FreeFloatingGeneralizedTorques_baseWrench(resc,resv,argc,(mxArray**)(argv)); break;
  case 1124: flag=_wrap_FreeFloatingGeneralizedTorques_jointTorques(resc,resv,argc,(mxArray**)(argv)); break;
  case 1125: flag=_wrap_FreeFloatingGeneralizedTorques_getNrOfDOFs(resc,resv,argc,(mxArray**)(argv)); break;
  case 1126: flag=_wrap_delete_FreeFloatingGeneralizedTorques(resc,resv,argc,(mxArray**)(argv)); break;
  case 1127: flag=_wrap_new_FreeFloatingVel(resc,resv,argc,(mxArray**)(argv)); break;
  case 1128: flag=_wrap_FreeFloatingVel_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1129: flag=_wrap_FreeFloatingVel_baseVel(resc,resv,argc,(mxArray**)(argv)); break;
  case 1130: flag=_wrap_FreeFloatingVel_jointVel(resc,resv,argc,(mxArray**)(argv)); break;
  case 1131: flag=_wrap_FreeFloatingVel_getNrOfDOFs(resc,resv,argc,(mxArray**)(argv)); break;
  case 1132: flag=_wrap_delete_FreeFloatingVel(resc,resv,argc,(mxArray**)(argv)); break;
  case 1133: flag=_wrap_new_FreeFloatingAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 1134: flag=_wrap_FreeFloatingAcc_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1135: flag=_wrap_FreeFloatingAcc_baseAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 1136: flag=_wrap_FreeFloatingAcc_jointAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 1137: flag=_wrap_FreeFloatingAcc_getNrOfDOFs(resc,resv,argc,(mxArray**)(argv)); break;
  case 1138: flag=_wrap_delete_FreeFloatingAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 1139: flag=_wrap_ContactWrench_contactId(resc,resv,argc,(mxArray**)(argv)); break;
  case 1140: flag=_wrap_ContactWrench_contactPoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1141: flag=_wrap_ContactWrench_contactWrench(resc,resv,argc,(mxArray**)(argv)); break;
  case 1142: flag=_wrap_new_ContactWrench(resc,resv,argc,(mxArray**)(argv)); break;
  case 1143: flag=_wrap_delete_ContactWrench(resc,resv,argc,(mxArray**)(argv)); break;
  case 1144: flag=_wrap_new_LinkContactWrenches(resc,resv,argc,(mxArray**)(argv)); break;
  case 1145: flag=_wrap_LinkContactWrenches_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1146: flag=_wrap_LinkContactWrenches_getNrOfContactsForLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1147: flag=_wrap_LinkContactWrenches_setNrOfContactsForLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1148: flag=_wrap_LinkContactWrenches_getNrOfLinks(resc,resv,argc,(mxArray**)(argv)); break;
  case 1149: flag=_wrap_LinkContactWrenches_contactWrench(resc,resv,argc,(mxArray**)(argv)); break;
  case 1150: flag=_wrap_LinkContactWrenches_computeNetWrenches(resc,resv,argc,(mxArray**)(argv)); break;
  case 1151: flag=_wrap_LinkContactWrenches_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 1152: flag=_wrap_delete_LinkContactWrenches(resc,resv,argc,(mxArray**)(argv)); break;
  case 1153: flag=_wrap_SolidShapesVector_pop(resc,resv,argc,(mxArray**)(argv)); break;
  case 1154: flag=_wrap_SolidShapesVector_brace(resc,resv,argc,(mxArray**)(argv)); break;
  case 1155: flag=_wrap_SolidShapesVector_setbrace(resc,resv,argc,(mxArray**)(argv)); break;
  case 1156: flag=_wrap_SolidShapesVector_append(resc,resv,argc,(mxArray**)(argv)); break;
  case 1157: flag=_wrap_SolidShapesVector_empty(resc,resv,argc,(mxArray**)(argv)); break;
  case 1158: flag=_wrap_SolidShapesVector_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 1159: flag=_wrap_SolidShapesVector_swap(resc,resv,argc,(mxArray**)(argv)); break;
  case 1160: flag=_wrap_SolidShapesVector_begin(resc,resv,argc,(mxArray**)(argv)); break;
  case 1161: flag=_wrap_SolidShapesVector_end(resc,resv,argc,(mxArray**)(argv)); break;
  case 1162: flag=_wrap_SolidShapesVector_rbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 1163: flag=_wrap_SolidShapesVector_rend(resc,resv,argc,(mxArray**)(argv)); break;
  case 1164: flag=_wrap_SolidShapesVector_clear(resc,resv,argc,(mxArray**)(argv)); break;
  case 1165: flag=_wrap_SolidShapesVector_get_allocator(resc,resv,argc,(mxArray**)(argv)); break;
  case 1166: flag=_wrap_SolidShapesVector_pop_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 1167: flag=_wrap_SolidShapesVector_erase(resc,resv,argc,(mxArray**)(argv)); break;
  case 1168: flag=_wrap_new_SolidShapesVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 1169: flag=_wrap_SolidShapesVector_push_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 1170: flag=_wrap_SolidShapesVector_front(resc,resv,argc,(mxArray**)(argv)); break;
  case 1171: flag=_wrap_SolidShapesVector_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 1172: flag=_wrap_SolidShapesVector_assign(resc,resv,argc,(mxArray**)(argv)); break;
  case 1173: flag=_wrap_SolidShapesVector_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1174: flag=_wrap_SolidShapesVector_insert(resc,resv,argc,(mxArray**)(argv)); break;
  case 1175: flag=_wrap_SolidShapesVector_reserve(resc,resv,argc,(mxArray**)(argv)); break;
  case 1176: flag=_wrap_SolidShapesVector_capacity(resc,resv,argc,(mxArray**)(argv)); break;
  case 1177: flag=_wrap_delete_SolidShapesVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 1178: flag=_wrap_LinksSolidShapesVector_pop(resc,resv,argc,(mxArray**)(argv)); break;
  case 1179: flag=_wrap_LinksSolidShapesVector_brace(resc,resv,argc,(mxArray**)(argv)); break;
  case 1180: flag=_wrap_LinksSolidShapesVector_setbrace(resc,resv,argc,(mxArray**)(argv)); break;
  case 1181: flag=_wrap_LinksSolidShapesVector_append(resc,resv,argc,(mxArray**)(argv)); break;
  case 1182: flag=_wrap_LinksSolidShapesVector_empty(resc,resv,argc,(mxArray**)(argv)); break;
  case 1183: flag=_wrap_LinksSolidShapesVector_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 1184: flag=_wrap_LinksSolidShapesVector_swap(resc,resv,argc,(mxArray**)(argv)); break;
  case 1185: flag=_wrap_LinksSolidShapesVector_begin(resc,resv,argc,(mxArray**)(argv)); break;
  case 1186: flag=_wrap_LinksSolidShapesVector_end(resc,resv,argc,(mxArray**)(argv)); break;
  case 1187: flag=_wrap_LinksSolidShapesVector_rbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 1188: flag=_wrap_LinksSolidShapesVector_rend(resc,resv,argc,(mxArray**)(argv)); break;
  case 1189: flag=_wrap_LinksSolidShapesVector_clear(resc,resv,argc,(mxArray**)(argv)); break;
  case 1190: flag=_wrap_LinksSolidShapesVector_get_allocator(resc,resv,argc,(mxArray**)(argv)); break;
  case 1191: flag=_wrap_LinksSolidShapesVector_pop_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 1192: flag=_wrap_LinksSolidShapesVector_erase(resc,resv,argc,(mxArray**)(argv)); break;
  case 1193: flag=_wrap_new_LinksSolidShapesVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 1194: flag=_wrap_LinksSolidShapesVector_push_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 1195: flag=_wrap_LinksSolidShapesVector_front(resc,resv,argc,(mxArray**)(argv)); break;
  case 1196: flag=_wrap_LinksSolidShapesVector_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 1197: flag=_wrap_LinksSolidShapesVector_assign(resc,resv,argc,(mxArray**)(argv)); break;
  case 1198: flag=_wrap_LinksSolidShapesVector_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1199: flag=_wrap_LinksSolidShapesVector_insert(resc,resv,argc,(mxArray**)(argv)); break;
  case 1200: flag=_wrap_LinksSolidShapesVector_reserve(resc,resv,argc,(mxArray**)(argv)); break;
  case 1201: flag=_wrap_LinksSolidShapesVector_capacity(resc,resv,argc,(mxArray**)(argv)); break;
  case 1202: flag=_wrap_delete_LinksSolidShapesVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 1203: flag=_wrap_ForwardPositionKinematics(resc,resv,argc,(mxArray**)(argv)); break;
  case 1204: flag=_wrap_ForwardVelAccKinematics(resc,resv,argc,(mxArray**)(argv)); break;
  case 1205: flag=_wrap_ForwardPosVelAccKinematics(resc,resv,argc,(mxArray**)(argv)); break;
  case 1206: flag=_wrap_ForwardPosVelKinematics(resc,resv,argc,(mxArray**)(argv)); break;
  case 1207: flag=_wrap_ForwardAccKinematics(resc,resv,argc,(mxArray**)(argv)); break;
  case 1208: flag=_wrap_ForwardBiasAccKinematics(resc,resv,argc,(mxArray**)(argv)); break;
  case 1209: flag=_wrap_ComputeLinearAndAngularMomentum(resc,resv,argc,(mxArray**)(argv)); break;
  case 1210: flag=_wrap_ComputeLinearAndAngularMomentumDerivativeBias(resc,resv,argc,(mxArray**)(argv)); break;
  case 1211: flag=_wrap_RNEADynamicPhase(resc,resv,argc,(mxArray**)(argv)); break;
  case 1212: flag=_wrap_CompositeRigidBodyAlgorithm(resc,resv,argc,(mxArray**)(argv)); break;
  case 1213: flag=_wrap_new_ArticulatedBodyAlgorithmInternalBuffers(resc,resv,argc,(mxArray**)(argv)); break;
  case 1214: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1215: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 1216: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_S_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1217: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_S_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1218: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_U_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1219: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_U_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1220: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_D_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1221: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_D_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1222: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_u_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1223: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_u_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1224: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_linksVel_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1225: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_linksVel_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1226: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_linksBiasAcceleration_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1227: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_linksBiasAcceleration_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1228: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_linksAccelerations_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1229: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_linksAccelerations_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1230: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_linkABIs_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1231: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_linkABIs_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1232: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_linksBiasWrench_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1233: flag=_wrap_ArticulatedBodyAlgorithmInternalBuffers_linksBiasWrench_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1234: flag=_wrap_delete_ArticulatedBodyAlgorithmInternalBuffers(resc,resv,argc,(mxArray**)(argv)); break;
  case 1235: flag=_wrap_ArticulatedBodyAlgorithm(resc,resv,argc,(mxArray**)(argv)); break;
  case 1236: flag=_wrap_InverseDynamicsInertialParametersRegressor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1237: flag=_wrap_NR_OF_SENSOR_TYPES_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1238: flag=_wrap_isLinkSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1239: flag=_wrap_isJointSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1240: flag=_wrap_getSensorTypeSize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1241: flag=_wrap_delete_Sensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1242: flag=_wrap_Sensor_getName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1243: flag=_wrap_Sensor_getSensorType(resc,resv,argc,(mxArray**)(argv)); break;
  case 1244: flag=_wrap_Sensor_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 1245: flag=_wrap_Sensor_setName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1246: flag=_wrap_Sensor_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 1247: flag=_wrap_Sensor_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 1248: flag=_wrap_Sensor_updateIndices(resc,resv,argc,(mxArray**)(argv)); break;
  case 1249: flag=_wrap_delete_JointSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1250: flag=_wrap_JointSensor_getParentJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1251: flag=_wrap_JointSensor_getParentJointIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1252: flag=_wrap_JointSensor_setParentJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1253: flag=_wrap_JointSensor_setParentJointIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1254: flag=_wrap_JointSensor_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 1255: flag=_wrap_delete_LinkSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1256: flag=_wrap_LinkSensor_getParentLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1257: flag=_wrap_LinkSensor_getParentLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1258: flag=_wrap_LinkSensor_getLinkSensorTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1259: flag=_wrap_LinkSensor_setParentLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1260: flag=_wrap_LinkSensor_setParentLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1261: flag=_wrap_LinkSensor_setLinkSensorTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1262: flag=_wrap_LinkSensor_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 1263: flag=_wrap_new_SensorsList(resc,resv,argc,(mxArray**)(argv)); break;
  case 1264: flag=_wrap_delete_SensorsList(resc,resv,argc,(mxArray**)(argv)); break;
  case 1265: flag=_wrap_SensorsList_addSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1266: flag=_wrap_SensorsList_setSerialization(resc,resv,argc,(mxArray**)(argv)); break;
  case 1267: flag=_wrap_SensorsList_getSerialization(resc,resv,argc,(mxArray**)(argv)); break;
  case 1268: flag=_wrap_SensorsList_getNrOfSensors(resc,resv,argc,(mxArray**)(argv)); break;
  case 1269: flag=_wrap_SensorsList_getSensorIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1270: flag=_wrap_SensorsList_getSizeOfAllSensorsMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1271: flag=_wrap_SensorsList_getSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1272: flag=_wrap_SensorsList_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 1273: flag=_wrap_SensorsList_removeSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1274: flag=_wrap_SensorsList_removeAllSensorsOfType(resc,resv,argc,(mxArray**)(argv)); break;
  case 1275: flag=_wrap_SensorsList_getSixAxisForceTorqueSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1276: flag=_wrap_SensorsList_getAccelerometerSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1277: flag=_wrap_SensorsList_getGyroscopeSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1278: flag=_wrap_SensorsList_getThreeAxisAngularAccelerometerSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1279: flag=_wrap_SensorsList_getThreeAxisForceTorqueContactSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1280: flag=_wrap_new_SensorsMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1281: flag=_wrap_delete_SensorsMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1282: flag=_wrap_SensorsMeasurements_setNrOfSensors(resc,resv,argc,(mxArray**)(argv)); break;
  case 1283: flag=_wrap_SensorsMeasurements_getNrOfSensors(resc,resv,argc,(mxArray**)(argv)); break;
  case 1284: flag=_wrap_SensorsMeasurements_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1285: flag=_wrap_SensorsMeasurements_toVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 1286: flag=_wrap_SensorsMeasurements_setMeasurement(resc,resv,argc,(mxArray**)(argv)); break;
  case 1287: flag=_wrap_SensorsMeasurements_getMeasurement(resc,resv,argc,(mxArray**)(argv)); break;
  case 1288: flag=_wrap_SensorsMeasurements_getSizeOfAllSensorsMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1289: flag=_wrap_new_SixAxisForceTorqueSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1290: flag=_wrap_delete_SixAxisForceTorqueSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1291: flag=_wrap_SixAxisForceTorqueSensor_setName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1292: flag=_wrap_SixAxisForceTorqueSensor_setFirstLinkSensorTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1293: flag=_wrap_SixAxisForceTorqueSensor_setSecondLinkSensorTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1294: flag=_wrap_SixAxisForceTorqueSensor_getFirstLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1295: flag=_wrap_SixAxisForceTorqueSensor_getSecondLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1296: flag=_wrap_SixAxisForceTorqueSensor_setFirstLinkName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1297: flag=_wrap_SixAxisForceTorqueSensor_setSecondLinkName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1298: flag=_wrap_SixAxisForceTorqueSensor_getFirstLinkName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1299: flag=_wrap_SixAxisForceTorqueSensor_getSecondLinkName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1300: flag=_wrap_SixAxisForceTorqueSensor_setParentJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1301: flag=_wrap_SixAxisForceTorqueSensor_setParentJointIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1302: flag=_wrap_SixAxisForceTorqueSensor_setAppliedWrenchLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1303: flag=_wrap_SixAxisForceTorqueSensor_getName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1304: flag=_wrap_SixAxisForceTorqueSensor_getSensorType(resc,resv,argc,(mxArray**)(argv)); break;
  case 1305: flag=_wrap_SixAxisForceTorqueSensor_getParentJoint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1306: flag=_wrap_SixAxisForceTorqueSensor_getParentJointIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1307: flag=_wrap_SixAxisForceTorqueSensor_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 1308: flag=_wrap_SixAxisForceTorqueSensor_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 1309: flag=_wrap_SixAxisForceTorqueSensor_updateIndices(resc,resv,argc,(mxArray**)(argv)); break;
  case 1310: flag=_wrap_SixAxisForceTorqueSensor_getAppliedWrenchLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1311: flag=_wrap_SixAxisForceTorqueSensor_isLinkAttachedToSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1312: flag=_wrap_SixAxisForceTorqueSensor_getLinkSensorTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1313: flag=_wrap_SixAxisForceTorqueSensor_getWrenchAppliedOnLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1314: flag=_wrap_SixAxisForceTorqueSensor_getWrenchAppliedOnLinkMatrix(resc,resv,argc,(mxArray**)(argv)); break;
  case 1315: flag=_wrap_SixAxisForceTorqueSensor_getWrenchAppliedOnLinkInverseMatrix(resc,resv,argc,(mxArray**)(argv)); break;
  case 1316: flag=_wrap_SixAxisForceTorqueSensor_predictMeasurement(resc,resv,argc,(mxArray**)(argv)); break;
  case 1317: flag=_wrap_SixAxisForceTorqueSensor_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 1318: flag=_wrap_new_AccelerometerSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1319: flag=_wrap_delete_AccelerometerSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1320: flag=_wrap_AccelerometerSensor_setName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1321: flag=_wrap_AccelerometerSensor_setLinkSensorTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1322: flag=_wrap_AccelerometerSensor_setParentLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1323: flag=_wrap_AccelerometerSensor_setParentLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1324: flag=_wrap_AccelerometerSensor_getName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1325: flag=_wrap_AccelerometerSensor_getSensorType(resc,resv,argc,(mxArray**)(argv)); break;
  case 1326: flag=_wrap_AccelerometerSensor_getParentLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1327: flag=_wrap_AccelerometerSensor_getParentLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1328: flag=_wrap_AccelerometerSensor_getLinkSensorTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1329: flag=_wrap_AccelerometerSensor_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 1330: flag=_wrap_AccelerometerSensor_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 1331: flag=_wrap_AccelerometerSensor_updateIndices(resc,resv,argc,(mxArray**)(argv)); break;
  case 1332: flag=_wrap_AccelerometerSensor_predictMeasurement(resc,resv,argc,(mxArray**)(argv)); break;
  case 1333: flag=_wrap_new_GyroscopeSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1334: flag=_wrap_delete_GyroscopeSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1335: flag=_wrap_GyroscopeSensor_setName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1336: flag=_wrap_GyroscopeSensor_setLinkSensorTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1337: flag=_wrap_GyroscopeSensor_setParentLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1338: flag=_wrap_GyroscopeSensor_setParentLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1339: flag=_wrap_GyroscopeSensor_getName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1340: flag=_wrap_GyroscopeSensor_getSensorType(resc,resv,argc,(mxArray**)(argv)); break;
  case 1341: flag=_wrap_GyroscopeSensor_getParentLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1342: flag=_wrap_GyroscopeSensor_getParentLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1343: flag=_wrap_GyroscopeSensor_getLinkSensorTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1344: flag=_wrap_GyroscopeSensor_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 1345: flag=_wrap_GyroscopeSensor_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 1346: flag=_wrap_GyroscopeSensor_updateIndices(resc,resv,argc,(mxArray**)(argv)); break;
  case 1347: flag=_wrap_GyroscopeSensor_predictMeasurement(resc,resv,argc,(mxArray**)(argv)); break;
  case 1348: flag=_wrap_new_ThreeAxisAngularAccelerometerSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1349: flag=_wrap_delete_ThreeAxisAngularAccelerometerSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1350: flag=_wrap_ThreeAxisAngularAccelerometerSensor_setName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1351: flag=_wrap_ThreeAxisAngularAccelerometerSensor_setLinkSensorTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1352: flag=_wrap_ThreeAxisAngularAccelerometerSensor_setParentLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1353: flag=_wrap_ThreeAxisAngularAccelerometerSensor_setParentLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1354: flag=_wrap_ThreeAxisAngularAccelerometerSensor_getName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1355: flag=_wrap_ThreeAxisAngularAccelerometerSensor_getSensorType(resc,resv,argc,(mxArray**)(argv)); break;
  case 1356: flag=_wrap_ThreeAxisAngularAccelerometerSensor_getParentLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1357: flag=_wrap_ThreeAxisAngularAccelerometerSensor_getParentLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1358: flag=_wrap_ThreeAxisAngularAccelerometerSensor_getLinkSensorTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1359: flag=_wrap_ThreeAxisAngularAccelerometerSensor_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 1360: flag=_wrap_ThreeAxisAngularAccelerometerSensor_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 1361: flag=_wrap_ThreeAxisAngularAccelerometerSensor_updateIndices(resc,resv,argc,(mxArray**)(argv)); break;
  case 1362: flag=_wrap_ThreeAxisAngularAccelerometerSensor_predictMeasurement(resc,resv,argc,(mxArray**)(argv)); break;
  case 1363: flag=_wrap_new_ThreeAxisForceTorqueContactSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1364: flag=_wrap_delete_ThreeAxisForceTorqueContactSensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1365: flag=_wrap_ThreeAxisForceTorqueContactSensor_setName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1366: flag=_wrap_ThreeAxisForceTorqueContactSensor_setLinkSensorTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1367: flag=_wrap_ThreeAxisForceTorqueContactSensor_setParentLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1368: flag=_wrap_ThreeAxisForceTorqueContactSensor_setParentLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1369: flag=_wrap_ThreeAxisForceTorqueContactSensor_getName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1370: flag=_wrap_ThreeAxisForceTorqueContactSensor_getSensorType(resc,resv,argc,(mxArray**)(argv)); break;
  case 1371: flag=_wrap_ThreeAxisForceTorqueContactSensor_getParentLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1372: flag=_wrap_ThreeAxisForceTorqueContactSensor_getParentLinkIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1373: flag=_wrap_ThreeAxisForceTorqueContactSensor_getLinkSensorTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1374: flag=_wrap_ThreeAxisForceTorqueContactSensor_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 1375: flag=_wrap_ThreeAxisForceTorqueContactSensor_clone(resc,resv,argc,(mxArray**)(argv)); break;
  case 1376: flag=_wrap_ThreeAxisForceTorqueContactSensor_updateIndices(resc,resv,argc,(mxArray**)(argv)); break;
  case 1377: flag=_wrap_ThreeAxisForceTorqueContactSensor_setLoadCellLocations(resc,resv,argc,(mxArray**)(argv)); break;
  case 1378: flag=_wrap_ThreeAxisForceTorqueContactSensor_getLoadCellLocations(resc,resv,argc,(mxArray**)(argv)); break;
  case 1379: flag=_wrap_ThreeAxisForceTorqueContactSensor_computeThreeAxisForceTorqueFromLoadCellMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1380: flag=_wrap_ThreeAxisForceTorqueContactSensor_computeCenterOfPressureFromLoadCellMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1381: flag=_wrap_predictSensorsMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1382: flag=_wrap_predictSensorsMeasurementsFromRawBuffers(resc,resv,argc,(mxArray**)(argv)); break;
  case 1383: flag=_wrap_dofsListFromURDF(resc,resv,argc,(mxArray**)(argv)); break;
  case 1384: flag=_wrap_dofsListFromURDFString(resc,resv,argc,(mxArray**)(argv)); break;
  case 1385: flag=_wrap_ModelParserOptions_addSensorFramesAsAdditionalFrames_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1386: flag=_wrap_ModelParserOptions_addSensorFramesAsAdditionalFrames_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1387: flag=_wrap_ModelParserOptions_originalFilename_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1388: flag=_wrap_ModelParserOptions_originalFilename_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1389: flag=_wrap_new_ModelParserOptions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1390: flag=_wrap_delete_ModelParserOptions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1391: flag=_wrap_new_ModelLoader(resc,resv,argc,(mxArray**)(argv)); break;
  case 1392: flag=_wrap_delete_ModelLoader(resc,resv,argc,(mxArray**)(argv)); break;
  case 1393: flag=_wrap_ModelLoader_parsingOptions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1394: flag=_wrap_ModelLoader_setParsingOptions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1395: flag=_wrap_ModelLoader_loadModelFromString(resc,resv,argc,(mxArray**)(argv)); break;
  case 1396: flag=_wrap_ModelLoader_loadModelFromFile(resc,resv,argc,(mxArray**)(argv)); break;
  case 1397: flag=_wrap_ModelLoader_loadReducedModelFromFullModel(resc,resv,argc,(mxArray**)(argv)); break;
  case 1398: flag=_wrap_ModelLoader_loadReducedModelFromString(resc,resv,argc,(mxArray**)(argv)); break;
  case 1399: flag=_wrap_ModelLoader_loadReducedModelFromFile(resc,resv,argc,(mxArray**)(argv)); break;
  case 1400: flag=_wrap_ModelLoader_model(resc,resv,argc,(mxArray**)(argv)); break;
  case 1401: flag=_wrap_ModelLoader_sensors(resc,resv,argc,(mxArray**)(argv)); break;
  case 1402: flag=_wrap_ModelLoader_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 1403: flag=_wrap_ModelExporterOptions_baseLink_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1404: flag=_wrap_ModelExporterOptions_baseLink_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1405: flag=_wrap_ModelExporterOptions_exportFirstBaseLinkAdditionalFrameAsFakeURDFBase_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1406: flag=_wrap_ModelExporterOptions_exportFirstBaseLinkAdditionalFrameAsFakeURDFBase_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1407: flag=_wrap_ModelExporterOptions_robotExportedName_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1408: flag=_wrap_ModelExporterOptions_robotExportedName_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1409: flag=_wrap_new_ModelExporterOptions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1410: flag=_wrap_delete_ModelExporterOptions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1411: flag=_wrap_new_ModelExporter(resc,resv,argc,(mxArray**)(argv)); break;
  case 1412: flag=_wrap_delete_ModelExporter(resc,resv,argc,(mxArray**)(argv)); break;
  case 1413: flag=_wrap_ModelExporter_exportingOptions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1414: flag=_wrap_ModelExporter_setExportingOptions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1415: flag=_wrap_ModelExporter_init(resc,resv,argc,(mxArray**)(argv)); break;
  case 1416: flag=_wrap_ModelExporter_model(resc,resv,argc,(mxArray**)(argv)); break;
  case 1417: flag=_wrap_ModelExporter_sensors(resc,resv,argc,(mxArray**)(argv)); break;
  case 1418: flag=_wrap_ModelExporter_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 1419: flag=_wrap_ModelExporter_exportModelToString(resc,resv,argc,(mxArray**)(argv)); break;
  case 1420: flag=_wrap_ModelExporter_exportModelToFile(resc,resv,argc,(mxArray**)(argv)); break;
  case 1421: flag=_wrap_new_ModelCalibrationHelper(resc,resv,argc,(mxArray**)(argv)); break;
  case 1422: flag=_wrap_delete_ModelCalibrationHelper(resc,resv,argc,(mxArray**)(argv)); break;
  case 1423: flag=_wrap_ModelCalibrationHelper_loadModelFromString(resc,resv,argc,(mxArray**)(argv)); break;
  case 1424: flag=_wrap_ModelCalibrationHelper_loadModelFromFile(resc,resv,argc,(mxArray**)(argv)); break;
  case 1425: flag=_wrap_ModelCalibrationHelper_updateModelInertialParametersToString(resc,resv,argc,(mxArray**)(argv)); break;
  case 1426: flag=_wrap_ModelCalibrationHelper_updateModelInertialParametersToFile(resc,resv,argc,(mxArray**)(argv)); break;
  case 1427: flag=_wrap_ModelCalibrationHelper_model(resc,resv,argc,(mxArray**)(argv)); break;
  case 1428: flag=_wrap_ModelCalibrationHelper_sensors(resc,resv,argc,(mxArray**)(argv)); break;
  case 1429: flag=_wrap_ModelCalibrationHelper_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 1430: flag=_wrap_new_UnknownWrenchContact(resc,resv,argc,(mxArray**)(argv)); break;
  case 1431: flag=_wrap_UnknownWrenchContact_unknownType_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1432: flag=_wrap_UnknownWrenchContact_unknownType_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1433: flag=_wrap_UnknownWrenchContact_contactPoint_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1434: flag=_wrap_UnknownWrenchContact_contactPoint_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1435: flag=_wrap_UnknownWrenchContact_forceDirection_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1436: flag=_wrap_UnknownWrenchContact_forceDirection_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1437: flag=_wrap_UnknownWrenchContact_knownWrench_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1438: flag=_wrap_UnknownWrenchContact_knownWrench_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1439: flag=_wrap_UnknownWrenchContact_contactId_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1440: flag=_wrap_UnknownWrenchContact_contactId_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1441: flag=_wrap_delete_UnknownWrenchContact(resc,resv,argc,(mxArray**)(argv)); break;
  case 1442: flag=_wrap_new_LinkUnknownWrenchContacts(resc,resv,argc,(mxArray**)(argv)); break;
  case 1443: flag=_wrap_LinkUnknownWrenchContacts_clear(resc,resv,argc,(mxArray**)(argv)); break;
  case 1444: flag=_wrap_LinkUnknownWrenchContacts_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1445: flag=_wrap_LinkUnknownWrenchContacts_getNrOfContactsForLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1446: flag=_wrap_LinkUnknownWrenchContacts_setNrOfContactsForLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1447: flag=_wrap_LinkUnknownWrenchContacts_addNewContactForLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1448: flag=_wrap_LinkUnknownWrenchContacts_addNewContactInFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 1449: flag=_wrap_LinkUnknownWrenchContacts_addNewUnknownFullWrenchInFrameOrigin(resc,resv,argc,(mxArray**)(argv)); break;
  case 1450: flag=_wrap_LinkUnknownWrenchContacts_contactWrench(resc,resv,argc,(mxArray**)(argv)); break;
  case 1451: flag=_wrap_LinkUnknownWrenchContacts_toString(resc,resv,argc,(mxArray**)(argv)); break;
  case 1452: flag=_wrap_delete_LinkUnknownWrenchContacts(resc,resv,argc,(mxArray**)(argv)); break;
  case 1453: flag=_wrap_new_estimateExternalWrenchesBuffers(resc,resv,argc,(mxArray**)(argv)); break;
  case 1454: flag=_wrap_estimateExternalWrenchesBuffers_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1455: flag=_wrap_estimateExternalWrenchesBuffers_getNrOfSubModels(resc,resv,argc,(mxArray**)(argv)); break;
  case 1456: flag=_wrap_estimateExternalWrenchesBuffers_getNrOfLinks(resc,resv,argc,(mxArray**)(argv)); break;
  case 1457: flag=_wrap_estimateExternalWrenchesBuffers_isConsistent(resc,resv,argc,(mxArray**)(argv)); break;
  case 1458: flag=_wrap_estimateExternalWrenchesBuffers_A_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1459: flag=_wrap_estimateExternalWrenchesBuffers_A_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1460: flag=_wrap_estimateExternalWrenchesBuffers_x_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1461: flag=_wrap_estimateExternalWrenchesBuffers_x_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1462: flag=_wrap_estimateExternalWrenchesBuffers_b_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1463: flag=_wrap_estimateExternalWrenchesBuffers_b_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1464: flag=_wrap_estimateExternalWrenchesBuffers_pinvA_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1465: flag=_wrap_estimateExternalWrenchesBuffers_pinvA_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1466: flag=_wrap_estimateExternalWrenchesBuffers_b_contacts_subtree_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1467: flag=_wrap_estimateExternalWrenchesBuffers_b_contacts_subtree_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1468: flag=_wrap_estimateExternalWrenchesBuffers_subModelBase_H_link_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1469: flag=_wrap_estimateExternalWrenchesBuffers_subModelBase_H_link_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1470: flag=_wrap_delete_estimateExternalWrenchesBuffers(resc,resv,argc,(mxArray**)(argv)); break;
  case 1471: flag=_wrap_estimateExternalWrenchesWithoutInternalFT(resc,resv,argc,(mxArray**)(argv)); break;
  case 1472: flag=_wrap_estimateExternalWrenches(resc,resv,argc,(mxArray**)(argv)); break;
  case 1473: flag=_wrap_dynamicsEstimationForwardVelAccKinematics(resc,resv,argc,(mxArray**)(argv)); break;
  case 1474: flag=_wrap_dynamicsEstimationForwardVelKinematics(resc,resv,argc,(mxArray**)(argv)); break;
  case 1475: flag=_wrap_computeLinkNetWrenchesWithoutGravity(resc,resv,argc,(mxArray**)(argv)); break;
  case 1476: flag=_wrap_estimateLinkContactWrenchesFromLinkNetExternalWrenches(resc,resv,argc,(mxArray**)(argv)); break;
  case 1477: flag=_wrap_new_ExtWrenchesAndJointTorquesEstimator(resc,resv,argc,(mxArray**)(argv)); break;
  case 1478: flag=_wrap_delete_ExtWrenchesAndJointTorquesEstimator(resc,resv,argc,(mxArray**)(argv)); break;
  case 1479: flag=_wrap_ExtWrenchesAndJointTorquesEstimator_setModelAndSensors(resc,resv,argc,(mxArray**)(argv)); break;
  case 1480: flag=_wrap_ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFile(resc,resv,argc,(mxArray**)(argv)); break;
  case 1481: flag=_wrap_ExtWrenchesAndJointTorquesEstimator_loadModelAndSensorsFromFileWithSpecifiedDOFs(resc,resv,argc,(mxArray**)(argv)); break;
  case 1482: flag=_wrap_ExtWrenchesAndJointTorquesEstimator_model(resc,resv,argc,(mxArray**)(argv)); break;
  case 1483: flag=_wrap_ExtWrenchesAndJointTorquesEstimator_sensors(resc,resv,argc,(mxArray**)(argv)); break;
  case 1484: flag=_wrap_ExtWrenchesAndJointTorquesEstimator_submodels(resc,resv,argc,(mxArray**)(argv)); break;
  case 1485: flag=_wrap_ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFloatingBase(resc,resv,argc,(mxArray**)(argv)); break;
  case 1486: flag=_wrap_ExtWrenchesAndJointTorquesEstimator_updateKinematicsFromFixedBase(resc,resv,argc,(mxArray**)(argv)); break;
  case 1487: flag=_wrap_ExtWrenchesAndJointTorquesEstimator_computeExpectedFTSensorsMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1488: flag=_wrap_ExtWrenchesAndJointTorquesEstimator_estimateExtWrenchesAndJointTorques(resc,resv,argc,(mxArray**)(argv)); break;
  case 1489: flag=_wrap_ExtWrenchesAndJointTorquesEstimator_checkThatTheModelIsStill(resc,resv,argc,(mxArray**)(argv)); break;
  case 1490: flag=_wrap_ExtWrenchesAndJointTorquesEstimator_estimateLinkNetWrenchesWithoutGravity(resc,resv,argc,(mxArray**)(argv)); break;
  case 1491: flag=_wrap_new_SimpleLeggedOdometry(resc,resv,argc,(mxArray**)(argv)); break;
  case 1492: flag=_wrap_delete_SimpleLeggedOdometry(resc,resv,argc,(mxArray**)(argv)); break;
  case 1493: flag=_wrap_SimpleLeggedOdometry_setModel(resc,resv,argc,(mxArray**)(argv)); break;
  case 1494: flag=_wrap_SimpleLeggedOdometry_model(resc,resv,argc,(mxArray**)(argv)); break;
  case 1495: flag=_wrap_SimpleLeggedOdometry_updateKinematics(resc,resv,argc,(mxArray**)(argv)); break;
  case 1496: flag=_wrap_SimpleLeggedOdometry_init(resc,resv,argc,(mxArray**)(argv)); break;
  case 1497: flag=_wrap_SimpleLeggedOdometry_changeFixedFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 1498: flag=_wrap_SimpleLeggedOdometry_getCurrentFixedLink(resc,resv,argc,(mxArray**)(argv)); break;
  case 1499: flag=_wrap_SimpleLeggedOdometry_getWorldLinkTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1500: flag=_wrap_SimpleLeggedOdometry_getWorldFrameTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1501: flag=_wrap_isLinkBerdyDynamicVariable(resc,resv,argc,(mxArray**)(argv)); break;
  case 1502: flag=_wrap_isJointBerdyDynamicVariable(resc,resv,argc,(mxArray**)(argv)); break;
  case 1503: flag=_wrap_isDOFBerdyDynamicVariable(resc,resv,argc,(mxArray**)(argv)); break;
  case 1504: flag=_wrap_new_BerdyOptions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1505: flag=_wrap_BerdyOptions_berdyVariant_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1506: flag=_wrap_BerdyOptions_berdyVariant_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1507: flag=_wrap_BerdyOptions_includeAllNetExternalWrenchesAsDynamicVariables_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1508: flag=_wrap_BerdyOptions_includeAllNetExternalWrenchesAsDynamicVariables_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1509: flag=_wrap_BerdyOptions_includeAllJointAccelerationsAsSensors_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1510: flag=_wrap_BerdyOptions_includeAllJointAccelerationsAsSensors_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1511: flag=_wrap_BerdyOptions_includeAllJointTorquesAsSensors_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1512: flag=_wrap_BerdyOptions_includeAllJointTorquesAsSensors_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1513: flag=_wrap_BerdyOptions_includeAllNetExternalWrenchesAsSensors_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1514: flag=_wrap_BerdyOptions_includeAllNetExternalWrenchesAsSensors_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1515: flag=_wrap_BerdyOptions_includeFixedBaseExternalWrench_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1516: flag=_wrap_BerdyOptions_includeFixedBaseExternalWrench_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1517: flag=_wrap_BerdyOptions_jointOnWhichTheInternalWrenchIsMeasured_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1518: flag=_wrap_BerdyOptions_jointOnWhichTheInternalWrenchIsMeasured_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1519: flag=_wrap_BerdyOptions_baseLink_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1520: flag=_wrap_BerdyOptions_baseLink_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1521: flag=_wrap_BerdyOptions_checkConsistency(resc,resv,argc,(mxArray**)(argv)); break;
  case 1522: flag=_wrap_delete_BerdyOptions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1523: flag=_wrap_BerdySensor_type_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1524: flag=_wrap_BerdySensor_type_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1525: flag=_wrap_BerdySensor_id_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1526: flag=_wrap_BerdySensor_id_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1527: flag=_wrap_BerdySensor_range_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1528: flag=_wrap_BerdySensor_range_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1529: flag=_wrap_BerdySensor_eq(resc,resv,argc,(mxArray**)(argv)); break;
  case 1530: flag=_wrap_BerdySensor_lt(resc,resv,argc,(mxArray**)(argv)); break;
  case 1531: flag=_wrap_new_BerdySensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1532: flag=_wrap_delete_BerdySensor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1533: flag=_wrap_BerdyDynamicVariable_type_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1534: flag=_wrap_BerdyDynamicVariable_type_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1535: flag=_wrap_BerdyDynamicVariable_id_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1536: flag=_wrap_BerdyDynamicVariable_id_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1537: flag=_wrap_BerdyDynamicVariable_range_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1538: flag=_wrap_BerdyDynamicVariable_range_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1539: flag=_wrap_BerdyDynamicVariable_eq(resc,resv,argc,(mxArray**)(argv)); break;
  case 1540: flag=_wrap_BerdyDynamicVariable_lt(resc,resv,argc,(mxArray**)(argv)); break;
  case 1541: flag=_wrap_new_BerdyDynamicVariable(resc,resv,argc,(mxArray**)(argv)); break;
  case 1542: flag=_wrap_delete_BerdyDynamicVariable(resc,resv,argc,(mxArray**)(argv)); break;
  case 1543: flag=_wrap_new_BerdyHelper(resc,resv,argc,(mxArray**)(argv)); break;
  case 1544: flag=_wrap_BerdyHelper_dynamicTraversal(resc,resv,argc,(mxArray**)(argv)); break;
  case 1545: flag=_wrap_BerdyHelper_model(resc,resv,argc,(mxArray**)(argv)); break;
  case 1546: flag=_wrap_BerdyHelper_sensors(resc,resv,argc,(mxArray**)(argv)); break;
  case 1547: flag=_wrap_BerdyHelper_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 1548: flag=_wrap_BerdyHelper_init(resc,resv,argc,(mxArray**)(argv)); break;
  case 1549: flag=_wrap_BerdyHelper_getOptions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1550: flag=_wrap_BerdyHelper_getNrOfDynamicVariables(resc,resv,argc,(mxArray**)(argv)); break;
  case 1551: flag=_wrap_BerdyHelper_getNrOfDynamicEquations(resc,resv,argc,(mxArray**)(argv)); break;
  case 1552: flag=_wrap_BerdyHelper_getNrOfSensorsMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1553: flag=_wrap_BerdyHelper_resizeAndZeroBerdyMatrices(resc,resv,argc,(mxArray**)(argv)); break;
  case 1554: flag=_wrap_BerdyHelper_getBerdyMatrices(resc,resv,argc,(mxArray**)(argv)); break;
  case 1555: flag=_wrap_BerdyHelper_getSensorsOrdering(resc,resv,argc,(mxArray**)(argv)); break;
  case 1556: flag=_wrap_BerdyHelper_getRangeSensorVariable(resc,resv,argc,(mxArray**)(argv)); break;
  case 1557: flag=_wrap_BerdyHelper_getRangeDOFSensorVariable(resc,resv,argc,(mxArray**)(argv)); break;
  case 1558: flag=_wrap_BerdyHelper_getRangeJointSensorVariable(resc,resv,argc,(mxArray**)(argv)); break;
  case 1559: flag=_wrap_BerdyHelper_getRangeLinkSensorVariable(resc,resv,argc,(mxArray**)(argv)); break;
  case 1560: flag=_wrap_BerdyHelper_getRangeLinkVariable(resc,resv,argc,(mxArray**)(argv)); break;
  case 1561: flag=_wrap_BerdyHelper_getRangeJointVariable(resc,resv,argc,(mxArray**)(argv)); break;
  case 1562: flag=_wrap_BerdyHelper_getRangeDOFVariable(resc,resv,argc,(mxArray**)(argv)); break;
  case 1563: flag=_wrap_BerdyHelper_getDynamicVariablesOrdering(resc,resv,argc,(mxArray**)(argv)); break;
  case 1564: flag=_wrap_BerdyHelper_serializeDynamicVariables(resc,resv,argc,(mxArray**)(argv)); break;
  case 1565: flag=_wrap_BerdyHelper_serializeSensorVariables(resc,resv,argc,(mxArray**)(argv)); break;
  case 1566: flag=_wrap_BerdyHelper_serializeDynamicVariablesComputedFromFixedBaseRNEA(resc,resv,argc,(mxArray**)(argv)); break;
  case 1567: flag=_wrap_BerdyHelper_extractJointTorquesFromDynamicVariables(resc,resv,argc,(mxArray**)(argv)); break;
  case 1568: flag=_wrap_BerdyHelper_extractLinkNetExternalWrenchesFromDynamicVariables(resc,resv,argc,(mxArray**)(argv)); break;
  case 1569: flag=_wrap_BerdyHelper_updateKinematicsFromFloatingBase(resc,resv,argc,(mxArray**)(argv)); break;
  case 1570: flag=_wrap_BerdyHelper_updateKinematicsFromFixedBase(resc,resv,argc,(mxArray**)(argv)); break;
  case 1571: flag=_wrap_BerdyHelper_updateKinematicsFromTraversalFixedBase(resc,resv,argc,(mxArray**)(argv)); break;
  case 1572: flag=_wrap_BerdyHelper_setNetExternalWrenchMeasurementFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 1573: flag=_wrap_BerdyHelper_getNetExternalWrenchMeasurementFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 1574: flag=_wrap_delete_BerdyHelper(resc,resv,argc,(mxArray**)(argv)); break;
  case 1575: flag=_wrap_new_BerdySparseMAPSolver(resc,resv,argc,(mxArray**)(argv)); break;
  case 1576: flag=_wrap_delete_BerdySparseMAPSolver(resc,resv,argc,(mxArray**)(argv)); break;
  case 1577: flag=_wrap_BerdySparseMAPSolver_setDynamicsConstraintsPriorCovariance(resc,resv,argc,(mxArray**)(argv)); break;
  case 1578: flag=_wrap_BerdySparseMAPSolver_setDynamicsRegularizationPriorCovariance(resc,resv,argc,(mxArray**)(argv)); break;
  case 1579: flag=_wrap_BerdySparseMAPSolver_setDynamicsRegularizationPriorExpectedValue(resc,resv,argc,(mxArray**)(argv)); break;
  case 1580: flag=_wrap_BerdySparseMAPSolver_setMeasurementsPriorCovariance(resc,resv,argc,(mxArray**)(argv)); break;
  case 1581: flag=_wrap_BerdySparseMAPSolver_dynamicsConstraintsPriorCovarianceInverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 1582: flag=_wrap_BerdySparseMAPSolver_dynamicsRegularizationPriorCovarianceInverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 1583: flag=_wrap_BerdySparseMAPSolver_dynamicsRegularizationPriorExpectedValue(resc,resv,argc,(mxArray**)(argv)); break;
  case 1584: flag=_wrap_BerdySparseMAPSolver_measurementsPriorCovarianceInverse(resc,resv,argc,(mxArray**)(argv)); break;
  case 1585: flag=_wrap_BerdySparseMAPSolver_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 1586: flag=_wrap_BerdySparseMAPSolver_initialize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1587: flag=_wrap_BerdySparseMAPSolver_updateEstimateInformationFixedBase(resc,resv,argc,(mxArray**)(argv)); break;
  case 1588: flag=_wrap_BerdySparseMAPSolver_updateEstimateInformationFloatingBase(resc,resv,argc,(mxArray**)(argv)); break;
  case 1589: flag=_wrap_BerdySparseMAPSolver_doEstimate(resc,resv,argc,(mxArray**)(argv)); break;
  case 1590: flag=_wrap_BerdySparseMAPSolver_getLastEstimate(resc,resv,argc,(mxArray**)(argv)); break;
  case 1591: flag=_wrap_AttitudeEstimatorState_m_orientation_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1592: flag=_wrap_AttitudeEstimatorState_m_orientation_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1593: flag=_wrap_AttitudeEstimatorState_m_angular_velocity_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1594: flag=_wrap_AttitudeEstimatorState_m_angular_velocity_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1595: flag=_wrap_AttitudeEstimatorState_m_gyroscope_bias_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1596: flag=_wrap_AttitudeEstimatorState_m_gyroscope_bias_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1597: flag=_wrap_new_AttitudeEstimatorState(resc,resv,argc,(mxArray**)(argv)); break;
  case 1598: flag=_wrap_delete_AttitudeEstimatorState(resc,resv,argc,(mxArray**)(argv)); break;
  case 1599: flag=_wrap_delete_IAttitudeEstimator(resc,resv,argc,(mxArray**)(argv)); break;
  case 1600: flag=_wrap_IAttitudeEstimator_updateFilterWithMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1601: flag=_wrap_IAttitudeEstimator_propagateStates(resc,resv,argc,(mxArray**)(argv)); break;
  case 1602: flag=_wrap_IAttitudeEstimator_getOrientationEstimateAsRotationMatrix(resc,resv,argc,(mxArray**)(argv)); break;
  case 1603: flag=_wrap_IAttitudeEstimator_getOrientationEstimateAsQuaternion(resc,resv,argc,(mxArray**)(argv)); break;
  case 1604: flag=_wrap_IAttitudeEstimator_getOrientationEstimateAsRPY(resc,resv,argc,(mxArray**)(argv)); break;
  case 1605: flag=_wrap_IAttitudeEstimator_getInternalStateSize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1606: flag=_wrap_IAttitudeEstimator_getInternalState(resc,resv,argc,(mxArray**)(argv)); break;
  case 1607: flag=_wrap_IAttitudeEstimator_getDefaultInternalInitialState(resc,resv,argc,(mxArray**)(argv)); break;
  case 1608: flag=_wrap_IAttitudeEstimator_setInternalState(resc,resv,argc,(mxArray**)(argv)); break;
  case 1609: flag=_wrap_IAttitudeEstimator_setInternalStateInitialOrientation(resc,resv,argc,(mxArray**)(argv)); break;
  case 1610: flag=_wrap_AttitudeMahonyFilterParameters_time_step_in_seconds_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1611: flag=_wrap_AttitudeMahonyFilterParameters_time_step_in_seconds_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1612: flag=_wrap_AttitudeMahonyFilterParameters_kp_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1613: flag=_wrap_AttitudeMahonyFilterParameters_kp_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1614: flag=_wrap_AttitudeMahonyFilterParameters_ki_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1615: flag=_wrap_AttitudeMahonyFilterParameters_ki_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1616: flag=_wrap_AttitudeMahonyFilterParameters_use_magnetometer_measurements_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1617: flag=_wrap_AttitudeMahonyFilterParameters_use_magnetometer_measurements_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1618: flag=_wrap_AttitudeMahonyFilterParameters_confidence_magnetometer_measurements_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1619: flag=_wrap_AttitudeMahonyFilterParameters_confidence_magnetometer_measurements_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1620: flag=_wrap_new_AttitudeMahonyFilterParameters(resc,resv,argc,(mxArray**)(argv)); break;
  case 1621: flag=_wrap_delete_AttitudeMahonyFilterParameters(resc,resv,argc,(mxArray**)(argv)); break;
  case 1622: flag=_wrap_new_AttitudeMahonyFilter(resc,resv,argc,(mxArray**)(argv)); break;
  case 1623: flag=_wrap_AttitudeMahonyFilter_useMagnetoMeterMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1624: flag=_wrap_AttitudeMahonyFilter_setConfidenceForMagnetometerMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1625: flag=_wrap_AttitudeMahonyFilter_setGainkp(resc,resv,argc,(mxArray**)(argv)); break;
  case 1626: flag=_wrap_AttitudeMahonyFilter_setGainki(resc,resv,argc,(mxArray**)(argv)); break;
  case 1627: flag=_wrap_AttitudeMahonyFilter_setTimeStepInSeconds(resc,resv,argc,(mxArray**)(argv)); break;
  case 1628: flag=_wrap_AttitudeMahonyFilter_setGravityDirection(resc,resv,argc,(mxArray**)(argv)); break;
  case 1629: flag=_wrap_AttitudeMahonyFilter_setParameters(resc,resv,argc,(mxArray**)(argv)); break;
  case 1630: flag=_wrap_AttitudeMahonyFilter_getParameters(resc,resv,argc,(mxArray**)(argv)); break;
  case 1631: flag=_wrap_AttitudeMahonyFilter_updateFilterWithMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1632: flag=_wrap_AttitudeMahonyFilter_propagateStates(resc,resv,argc,(mxArray**)(argv)); break;
  case 1633: flag=_wrap_AttitudeMahonyFilter_getOrientationEstimateAsRotationMatrix(resc,resv,argc,(mxArray**)(argv)); break;
  case 1634: flag=_wrap_AttitudeMahonyFilter_getOrientationEstimateAsQuaternion(resc,resv,argc,(mxArray**)(argv)); break;
  case 1635: flag=_wrap_AttitudeMahonyFilter_getOrientationEstimateAsRPY(resc,resv,argc,(mxArray**)(argv)); break;
  case 1636: flag=_wrap_AttitudeMahonyFilter_getInternalStateSize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1637: flag=_wrap_AttitudeMahonyFilter_getInternalState(resc,resv,argc,(mxArray**)(argv)); break;
  case 1638: flag=_wrap_AttitudeMahonyFilter_getDefaultInternalInitialState(resc,resv,argc,(mxArray**)(argv)); break;
  case 1639: flag=_wrap_AttitudeMahonyFilter_setInternalState(resc,resv,argc,(mxArray**)(argv)); break;
  case 1640: flag=_wrap_AttitudeMahonyFilter_setInternalStateInitialOrientation(resc,resv,argc,(mxArray**)(argv)); break;
  case 1641: flag=_wrap_delete_AttitudeMahonyFilter(resc,resv,argc,(mxArray**)(argv)); break;
  case 1642: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekf_f(resc,resv,argc,(mxArray**)(argv)); break;
  case 1643: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekf_h(resc,resv,argc,(mxArray**)(argv)); break;
  case 1644: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianF(resc,resv,argc,(mxArray**)(argv)); break;
  case 1645: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfComputeJacobianH(resc,resv,argc,(mxArray**)(argv)); break;
  case 1646: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfPredict(resc,resv,argc,(mxArray**)(argv)); break;
  case 1647: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfUpdate(resc,resv,argc,(mxArray**)(argv)); break;
  case 1648: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfInit(resc,resv,argc,(mxArray**)(argv)); break;
  case 1649: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfReset(resc,resv,argc,(mxArray**)(argv)); break;
  case 1650: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfSetMeasurementVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 1651: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfSetInputVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 1652: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfSetInitialState(resc,resv,argc,(mxArray**)(argv)); break;
  case 1653: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfSetStateCovariance(resc,resv,argc,(mxArray**)(argv)); break;
  case 1654: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfSetSystemNoiseCovariance(resc,resv,argc,(mxArray**)(argv)); break;
  case 1655: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfSetMeasurementNoiseCovariance(resc,resv,argc,(mxArray**)(argv)); break;
  case 1656: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfSetStateSize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1657: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfSetInputSize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1658: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfSetOutputSize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1659: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfGetStates(resc,resv,argc,(mxArray**)(argv)); break;
  case 1660: flag=_wrap_DiscreteExtendedKalmanFilterHelper_ekfGetStateCovariance(resc,resv,argc,(mxArray**)(argv)); break;
  case 1661: flag=_wrap_delete_DiscreteExtendedKalmanFilterHelper(resc,resv,argc,(mxArray**)(argv)); break;
  case 1662: flag=_wrap_output_dimensions_with_magnetometer_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1663: flag=_wrap_output_dimensions_without_magnetometer_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1664: flag=_wrap_input_dimensions_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1665: flag=_wrap_AttitudeQuaternionEKFParameters_time_step_in_seconds_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1666: flag=_wrap_AttitudeQuaternionEKFParameters_time_step_in_seconds_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1667: flag=_wrap_AttitudeQuaternionEKFParameters_bias_correlation_time_factor_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1668: flag=_wrap_AttitudeQuaternionEKFParameters_bias_correlation_time_factor_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1669: flag=_wrap_AttitudeQuaternionEKFParameters_accelerometer_noise_variance_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1670: flag=_wrap_AttitudeQuaternionEKFParameters_accelerometer_noise_variance_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1671: flag=_wrap_AttitudeQuaternionEKFParameters_magnetometer_noise_variance_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1672: flag=_wrap_AttitudeQuaternionEKFParameters_magnetometer_noise_variance_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1673: flag=_wrap_AttitudeQuaternionEKFParameters_gyroscope_noise_variance_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1674: flag=_wrap_AttitudeQuaternionEKFParameters_gyroscope_noise_variance_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1675: flag=_wrap_AttitudeQuaternionEKFParameters_gyro_bias_noise_variance_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1676: flag=_wrap_AttitudeQuaternionEKFParameters_gyro_bias_noise_variance_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1677: flag=_wrap_AttitudeQuaternionEKFParameters_initial_orientation_error_variance_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1678: flag=_wrap_AttitudeQuaternionEKFParameters_initial_orientation_error_variance_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1679: flag=_wrap_AttitudeQuaternionEKFParameters_initial_ang_vel_error_variance_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1680: flag=_wrap_AttitudeQuaternionEKFParameters_initial_ang_vel_error_variance_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1681: flag=_wrap_AttitudeQuaternionEKFParameters_initial_gyro_bias_error_variance_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1682: flag=_wrap_AttitudeQuaternionEKFParameters_initial_gyro_bias_error_variance_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1683: flag=_wrap_AttitudeQuaternionEKFParameters_use_magnetometer_measurements_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1684: flag=_wrap_AttitudeQuaternionEKFParameters_use_magnetometer_measurements_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1685: flag=_wrap_new_AttitudeQuaternionEKFParameters(resc,resv,argc,(mxArray**)(argv)); break;
  case 1686: flag=_wrap_delete_AttitudeQuaternionEKFParameters(resc,resv,argc,(mxArray**)(argv)); break;
  case 1687: flag=_wrap_new_AttitudeQuaternionEKF(resc,resv,argc,(mxArray**)(argv)); break;
  case 1688: flag=_wrap_AttitudeQuaternionEKF_getParameters(resc,resv,argc,(mxArray**)(argv)); break;
  case 1689: flag=_wrap_AttitudeQuaternionEKF_setParameters(resc,resv,argc,(mxArray**)(argv)); break;
  case 1690: flag=_wrap_AttitudeQuaternionEKF_setGravityDirection(resc,resv,argc,(mxArray**)(argv)); break;
  case 1691: flag=_wrap_AttitudeQuaternionEKF_setTimeStepInSeconds(resc,resv,argc,(mxArray**)(argv)); break;
  case 1692: flag=_wrap_AttitudeQuaternionEKF_setBiasCorrelationTimeFactor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1693: flag=_wrap_AttitudeQuaternionEKF_useMagnetometerMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1694: flag=_wrap_AttitudeQuaternionEKF_setMeasurementNoiseVariance(resc,resv,argc,(mxArray**)(argv)); break;
  case 1695: flag=_wrap_AttitudeQuaternionEKF_setSystemNoiseVariance(resc,resv,argc,(mxArray**)(argv)); break;
  case 1696: flag=_wrap_AttitudeQuaternionEKF_setInitialStateCovariance(resc,resv,argc,(mxArray**)(argv)); break;
  case 1697: flag=_wrap_AttitudeQuaternionEKF_initializeFilter(resc,resv,argc,(mxArray**)(argv)); break;
  case 1698: flag=_wrap_AttitudeQuaternionEKF_updateFilterWithMeasurements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1699: flag=_wrap_AttitudeQuaternionEKF_propagateStates(resc,resv,argc,(mxArray**)(argv)); break;
  case 1700: flag=_wrap_AttitudeQuaternionEKF_getOrientationEstimateAsRotationMatrix(resc,resv,argc,(mxArray**)(argv)); break;
  case 1701: flag=_wrap_AttitudeQuaternionEKF_getOrientationEstimateAsQuaternion(resc,resv,argc,(mxArray**)(argv)); break;
  case 1702: flag=_wrap_AttitudeQuaternionEKF_getOrientationEstimateAsRPY(resc,resv,argc,(mxArray**)(argv)); break;
  case 1703: flag=_wrap_AttitudeQuaternionEKF_getInternalStateSize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1704: flag=_wrap_AttitudeQuaternionEKF_getInternalState(resc,resv,argc,(mxArray**)(argv)); break;
  case 1705: flag=_wrap_AttitudeQuaternionEKF_getDefaultInternalInitialState(resc,resv,argc,(mxArray**)(argv)); break;
  case 1706: flag=_wrap_AttitudeQuaternionEKF_setInternalState(resc,resv,argc,(mxArray**)(argv)); break;
  case 1707: flag=_wrap_AttitudeQuaternionEKF_setInternalStateInitialOrientation(resc,resv,argc,(mxArray**)(argv)); break;
  case 1708: flag=_wrap_delete_AttitudeQuaternionEKF(resc,resv,argc,(mxArray**)(argv)); break;
  case 1709: flag=_wrap_estimateInertialParametersFromLinkBoundingBoxesAndTotalMass(resc,resv,argc,(mxArray**)(argv)); break;
  case 1710: flag=_wrap_computeBoundingBoxFromShape(resc,resv,argc,(mxArray**)(argv)); break;
  case 1711: flag=_wrap_computeBoxVertices(resc,resv,argc,(mxArray**)(argv)); break;
  case 1712: flag=_wrap_new_KinDynComputations(resc,resv,argc,(mxArray**)(argv)); break;
  case 1713: flag=_wrap_delete_KinDynComputations(resc,resv,argc,(mxArray**)(argv)); break;
  case 1714: flag=_wrap_KinDynComputations_loadRobotModel(resc,resv,argc,(mxArray**)(argv)); break;
  case 1715: flag=_wrap_KinDynComputations_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 1716: flag=_wrap_KinDynComputations_setFrameVelocityRepresentation(resc,resv,argc,(mxArray**)(argv)); break;
  case 1717: flag=_wrap_KinDynComputations_getFrameVelocityRepresentation(resc,resv,argc,(mxArray**)(argv)); break;
  case 1718: flag=_wrap_KinDynComputations_getNrOfDegreesOfFreedom(resc,resv,argc,(mxArray**)(argv)); break;
  case 1719: flag=_wrap_KinDynComputations_getDescriptionOfDegreeOfFreedom(resc,resv,argc,(mxArray**)(argv)); break;
  case 1720: flag=_wrap_KinDynComputations_getDescriptionOfDegreesOfFreedom(resc,resv,argc,(mxArray**)(argv)); break;
  case 1721: flag=_wrap_KinDynComputations_getNrOfLinks(resc,resv,argc,(mxArray**)(argv)); break;
  case 1722: flag=_wrap_KinDynComputations_getNrOfFrames(resc,resv,argc,(mxArray**)(argv)); break;
  case 1723: flag=_wrap_KinDynComputations_getFloatingBase(resc,resv,argc,(mxArray**)(argv)); break;
  case 1724: flag=_wrap_KinDynComputations_setFloatingBase(resc,resv,argc,(mxArray**)(argv)); break;
  case 1725: flag=_wrap_KinDynComputations_model(resc,resv,argc,(mxArray**)(argv)); break;
  case 1726: flag=_wrap_KinDynComputations_getRobotModel(resc,resv,argc,(mxArray**)(argv)); break;
  case 1727: flag=_wrap_KinDynComputations_getRelativeJacobianSparsityPattern(resc,resv,argc,(mxArray**)(argv)); break;
  case 1728: flag=_wrap_KinDynComputations_getFrameFreeFloatingJacobianSparsityPattern(resc,resv,argc,(mxArray**)(argv)); break;
  case 1729: flag=_wrap_KinDynComputations_setJointPos(resc,resv,argc,(mxArray**)(argv)); break;
  case 1730: flag=_wrap_KinDynComputations_setRobotState(resc,resv,argc,(mxArray**)(argv)); break;
  case 1731: flag=_wrap_KinDynComputations_getRobotState(resc,resv,argc,(mxArray**)(argv)); break;
  case 1732: flag=_wrap_KinDynComputations_getWorldBaseTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1733: flag=_wrap_KinDynComputations_getBaseTwist(resc,resv,argc,(mxArray**)(argv)); break;
  case 1734: flag=_wrap_KinDynComputations_getJointPos(resc,resv,argc,(mxArray**)(argv)); break;
  case 1735: flag=_wrap_KinDynComputations_getJointVel(resc,resv,argc,(mxArray**)(argv)); break;
  case 1736: flag=_wrap_KinDynComputations_getModelVel(resc,resv,argc,(mxArray**)(argv)); break;
  case 1737: flag=_wrap_KinDynComputations_getFrameIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1738: flag=_wrap_KinDynComputations_getFrameName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1739: flag=_wrap_KinDynComputations_getWorldTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1740: flag=_wrap_KinDynComputations_getWorldTransformsAsHomogeneous(resc,resv,argc,(mxArray**)(argv)); break;
  case 1741: flag=_wrap_KinDynComputations_getRelativeTransformExplicit(resc,resv,argc,(mxArray**)(argv)); break;
  case 1742: flag=_wrap_KinDynComputations_getRelativeTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1743: flag=_wrap_KinDynComputations_getFrameVel(resc,resv,argc,(mxArray**)(argv)); break;
  case 1744: flag=_wrap_KinDynComputations_getFrameAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 1745: flag=_wrap_KinDynComputations_getFrameFreeFloatingJacobian(resc,resv,argc,(mxArray**)(argv)); break;
  case 1746: flag=_wrap_KinDynComputations_getRelativeJacobian(resc,resv,argc,(mxArray**)(argv)); break;
  case 1747: flag=_wrap_KinDynComputations_getRelativeJacobianExplicit(resc,resv,argc,(mxArray**)(argv)); break;
  case 1748: flag=_wrap_KinDynComputations_getFrameBiasAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 1749: flag=_wrap_KinDynComputations_getCenterOfMassPosition(resc,resv,argc,(mxArray**)(argv)); break;
  case 1750: flag=_wrap_KinDynComputations_getCenterOfMassVelocity(resc,resv,argc,(mxArray**)(argv)); break;
  case 1751: flag=_wrap_KinDynComputations_getCenterOfMassJacobian(resc,resv,argc,(mxArray**)(argv)); break;
  case 1752: flag=_wrap_KinDynComputations_getCenterOfMassBiasAcc(resc,resv,argc,(mxArray**)(argv)); break;
  case 1753: flag=_wrap_KinDynComputations_getAverageVelocity(resc,resv,argc,(mxArray**)(argv)); break;
  case 1754: flag=_wrap_KinDynComputations_getAverageVelocityJacobian(resc,resv,argc,(mxArray**)(argv)); break;
  case 1755: flag=_wrap_KinDynComputations_getCentroidalAverageVelocity(resc,resv,argc,(mxArray**)(argv)); break;
  case 1756: flag=_wrap_KinDynComputations_getCentroidalAverageVelocityJacobian(resc,resv,argc,(mxArray**)(argv)); break;
  case 1757: flag=_wrap_KinDynComputations_getLinearAngularMomentum(resc,resv,argc,(mxArray**)(argv)); break;
  case 1758: flag=_wrap_KinDynComputations_getLinearAngularMomentumJacobian(resc,resv,argc,(mxArray**)(argv)); break;
  case 1759: flag=_wrap_KinDynComputations_getCentroidalTotalMomentum(resc,resv,argc,(mxArray**)(argv)); break;
  case 1760: flag=_wrap_KinDynComputations_getCentroidalTotalMomentumJacobian(resc,resv,argc,(mxArray**)(argv)); break;
  case 1761: flag=_wrap_KinDynComputations_getFreeFloatingMassMatrix(resc,resv,argc,(mxArray**)(argv)); break;
  case 1762: flag=_wrap_KinDynComputations_inverseDynamics(resc,resv,argc,(mxArray**)(argv)); break;
  case 1763: flag=_wrap_KinDynComputations_generalizedBiasForces(resc,resv,argc,(mxArray**)(argv)); break;
  case 1764: flag=_wrap_KinDynComputations_generalizedGravityForces(resc,resv,argc,(mxArray**)(argv)); break;
  case 1765: flag=_wrap_KinDynComputations_generalizedExternalForces(resc,resv,argc,(mxArray**)(argv)); break;
  case 1766: flag=_wrap_KinDynComputations_inverseDynamicsInertialParametersRegressor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1767: flag=_wrap_Matrix4x4Vector_pop(resc,resv,argc,(mxArray**)(argv)); break;
  case 1768: flag=_wrap_Matrix4x4Vector_brace(resc,resv,argc,(mxArray**)(argv)); break;
  case 1769: flag=_wrap_Matrix4x4Vector_setbrace(resc,resv,argc,(mxArray**)(argv)); break;
  case 1770: flag=_wrap_Matrix4x4Vector_append(resc,resv,argc,(mxArray**)(argv)); break;
  case 1771: flag=_wrap_Matrix4x4Vector_empty(resc,resv,argc,(mxArray**)(argv)); break;
  case 1772: flag=_wrap_Matrix4x4Vector_size(resc,resv,argc,(mxArray**)(argv)); break;
  case 1773: flag=_wrap_Matrix4x4Vector_swap(resc,resv,argc,(mxArray**)(argv)); break;
  case 1774: flag=_wrap_Matrix4x4Vector_begin(resc,resv,argc,(mxArray**)(argv)); break;
  case 1775: flag=_wrap_Matrix4x4Vector_end(resc,resv,argc,(mxArray**)(argv)); break;
  case 1776: flag=_wrap_Matrix4x4Vector_rbegin(resc,resv,argc,(mxArray**)(argv)); break;
  case 1777: flag=_wrap_Matrix4x4Vector_rend(resc,resv,argc,(mxArray**)(argv)); break;
  case 1778: flag=_wrap_Matrix4x4Vector_clear(resc,resv,argc,(mxArray**)(argv)); break;
  case 1779: flag=_wrap_Matrix4x4Vector_get_allocator(resc,resv,argc,(mxArray**)(argv)); break;
  case 1780: flag=_wrap_Matrix4x4Vector_pop_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 1781: flag=_wrap_Matrix4x4Vector_erase(resc,resv,argc,(mxArray**)(argv)); break;
  case 1782: flag=_wrap_new_Matrix4x4Vector(resc,resv,argc,(mxArray**)(argv)); break;
  case 1783: flag=_wrap_Matrix4x4Vector_push_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 1784: flag=_wrap_Matrix4x4Vector_front(resc,resv,argc,(mxArray**)(argv)); break;
  case 1785: flag=_wrap_Matrix4x4Vector_back(resc,resv,argc,(mxArray**)(argv)); break;
  case 1786: flag=_wrap_Matrix4x4Vector_assign(resc,resv,argc,(mxArray**)(argv)); break;
  case 1787: flag=_wrap_Matrix4x4Vector_resize(resc,resv,argc,(mxArray**)(argv)); break;
  case 1788: flag=_wrap_Matrix4x4Vector_insert(resc,resv,argc,(mxArray**)(argv)); break;
  case 1789: flag=_wrap_Matrix4x4Vector_reserve(resc,resv,argc,(mxArray**)(argv)); break;
  case 1790: flag=_wrap_Matrix4x4Vector_capacity(resc,resv,argc,(mxArray**)(argv)); break;
  case 1791: flag=_wrap_Matrix4x4Vector_toMatlab(resc,resv,argc,(mxArray**)(argv)); break;
  case 1792: flag=_wrap_delete_Matrix4x4Vector(resc,resv,argc,(mxArray**)(argv)); break;
  case 1793: flag=_wrap_ICameraAnimator_enableMouseControl(resc,resv,argc,(mxArray**)(argv)); break;
  case 1794: flag=_wrap_ICameraAnimator_getMoveSpeed(resc,resv,argc,(mxArray**)(argv)); break;
  case 1795: flag=_wrap_ICameraAnimator_setMoveSpeed(resc,resv,argc,(mxArray**)(argv)); break;
  case 1796: flag=_wrap_ICameraAnimator_getRotateSpeed(resc,resv,argc,(mxArray**)(argv)); break;
  case 1797: flag=_wrap_ICameraAnimator_setRotateSpeed(resc,resv,argc,(mxArray**)(argv)); break;
  case 1798: flag=_wrap_ICameraAnimator_getZoomSpeed(resc,resv,argc,(mxArray**)(argv)); break;
  case 1799: flag=_wrap_ICameraAnimator_setZoomSpeed(resc,resv,argc,(mxArray**)(argv)); break;
  case 1800: flag=_wrap_delete_ICameraAnimator(resc,resv,argc,(mxArray**)(argv)); break;
  case 1801: flag=_wrap_delete_ICamera(resc,resv,argc,(mxArray**)(argv)); break;
  case 1802: flag=_wrap_ICamera_setPosition(resc,resv,argc,(mxArray**)(argv)); break;
  case 1803: flag=_wrap_ICamera_setTarget(resc,resv,argc,(mxArray**)(argv)); break;
  case 1804: flag=_wrap_ICamera_getPosition(resc,resv,argc,(mxArray**)(argv)); break;
  case 1805: flag=_wrap_ICamera_getTarget(resc,resv,argc,(mxArray**)(argv)); break;
  case 1806: flag=_wrap_ICamera_setUpVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 1807: flag=_wrap_ICamera_animator(resc,resv,argc,(mxArray**)(argv)); break;
  case 1808: flag=_wrap_ColorViz_r_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1809: flag=_wrap_ColorViz_r_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1810: flag=_wrap_ColorViz_g_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1811: flag=_wrap_ColorViz_g_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1812: flag=_wrap_ColorViz_b_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1813: flag=_wrap_ColorViz_b_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1814: flag=_wrap_ColorViz_a_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1815: flag=_wrap_ColorViz_a_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1816: flag=_wrap_new_ColorViz(resc,resv,argc,(mxArray**)(argv)); break;
  case 1817: flag=_wrap_delete_ColorViz(resc,resv,argc,(mxArray**)(argv)); break;
  case 1818: flag=_wrap_PixelViz_width_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1819: flag=_wrap_PixelViz_width_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1820: flag=_wrap_PixelViz_height_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1821: flag=_wrap_PixelViz_height_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1822: flag=_wrap_new_PixelViz(resc,resv,argc,(mxArray**)(argv)); break;
  case 1823: flag=_wrap_delete_PixelViz(resc,resv,argc,(mxArray**)(argv)); break;
  case 1824: flag=_wrap_delete_ILight(resc,resv,argc,(mxArray**)(argv)); break;
  case 1825: flag=_wrap_ILight_getName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1826: flag=_wrap_ILight_setType(resc,resv,argc,(mxArray**)(argv)); break;
  case 1827: flag=_wrap_ILight_getType(resc,resv,argc,(mxArray**)(argv)); break;
  case 1828: flag=_wrap_ILight_setPosition(resc,resv,argc,(mxArray**)(argv)); break;
  case 1829: flag=_wrap_ILight_getPosition(resc,resv,argc,(mxArray**)(argv)); break;
  case 1830: flag=_wrap_ILight_setDirection(resc,resv,argc,(mxArray**)(argv)); break;
  case 1831: flag=_wrap_ILight_getDirection(resc,resv,argc,(mxArray**)(argv)); break;
  case 1832: flag=_wrap_ILight_setAmbientColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1833: flag=_wrap_ILight_getAmbientColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1834: flag=_wrap_ILight_setSpecularColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1835: flag=_wrap_ILight_getSpecularColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1836: flag=_wrap_ILight_setDiffuseColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1837: flag=_wrap_ILight_getDiffuseColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1838: flag=_wrap_delete_IEnvironment(resc,resv,argc,(mxArray**)(argv)); break;
  case 1839: flag=_wrap_IEnvironment_getElements(resc,resv,argc,(mxArray**)(argv)); break;
  case 1840: flag=_wrap_IEnvironment_setElementVisibility(resc,resv,argc,(mxArray**)(argv)); break;
  case 1841: flag=_wrap_IEnvironment_setBackgroundColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1842: flag=_wrap_IEnvironment_setFloorGridColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1843: flag=_wrap_IEnvironment_setAmbientLight(resc,resv,argc,(mxArray**)(argv)); break;
  case 1844: flag=_wrap_IEnvironment_getLights(resc,resv,argc,(mxArray**)(argv)); break;
  case 1845: flag=_wrap_IEnvironment_addLight(resc,resv,argc,(mxArray**)(argv)); break;
  case 1846: flag=_wrap_IEnvironment_lightViz(resc,resv,argc,(mxArray**)(argv)); break;
  case 1847: flag=_wrap_IEnvironment_removeLight(resc,resv,argc,(mxArray**)(argv)); break;
  case 1848: flag=_wrap_delete_IJetsVisualization(resc,resv,argc,(mxArray**)(argv)); break;
  case 1849: flag=_wrap_IJetsVisualization_setJetsFrames(resc,resv,argc,(mxArray**)(argv)); break;
  case 1850: flag=_wrap_IJetsVisualization_getNrOfJets(resc,resv,argc,(mxArray**)(argv)); break;
  case 1851: flag=_wrap_IJetsVisualization_getJetDirection(resc,resv,argc,(mxArray**)(argv)); break;
  case 1852: flag=_wrap_IJetsVisualization_setJetDirection(resc,resv,argc,(mxArray**)(argv)); break;
  case 1853: flag=_wrap_IJetsVisualization_setJetColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1854: flag=_wrap_IJetsVisualization_setJetsDimensions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1855: flag=_wrap_IJetsVisualization_setJetsIntensity(resc,resv,argc,(mxArray**)(argv)); break;
  case 1856: flag=_wrap_delete_IVectorsVisualization(resc,resv,argc,(mxArray**)(argv)); break;
  case 1857: flag=_wrap_IVectorsVisualization_addVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 1858: flag=_wrap_IVectorsVisualization_getNrOfVectors(resc,resv,argc,(mxArray**)(argv)); break;
  case 1859: flag=_wrap_IVectorsVisualization_getVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 1860: flag=_wrap_IVectorsVisualization_updateVector(resc,resv,argc,(mxArray**)(argv)); break;
  case 1861: flag=_wrap_IVectorsVisualization_setVectorColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1862: flag=_wrap_IVectorsVisualization_setVectorsAspect(resc,resv,argc,(mxArray**)(argv)); break;
  case 1863: flag=_wrap_delete_IFrameVisualization(resc,resv,argc,(mxArray**)(argv)); break;
  case 1864: flag=_wrap_IFrameVisualization_addFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 1865: flag=_wrap_IFrameVisualization_setVisible(resc,resv,argc,(mxArray**)(argv)); break;
  case 1866: flag=_wrap_IFrameVisualization_getNrOfFrames(resc,resv,argc,(mxArray**)(argv)); break;
  case 1867: flag=_wrap_IFrameVisualization_getFrameTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1868: flag=_wrap_IFrameVisualization_updateFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 1869: flag=_wrap_delete_IModelVisualization(resc,resv,argc,(mxArray**)(argv)); break;
  case 1870: flag=_wrap_IModelVisualization_setPositions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1871: flag=_wrap_IModelVisualization_setLinkPositions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1872: flag=_wrap_IModelVisualization_model(resc,resv,argc,(mxArray**)(argv)); break;
  case 1873: flag=_wrap_IModelVisualization_getInstanceName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1874: flag=_wrap_IModelVisualization_setModelVisibility(resc,resv,argc,(mxArray**)(argv)); break;
  case 1875: flag=_wrap_IModelVisualization_setModelColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1876: flag=_wrap_IModelVisualization_resetModelColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1877: flag=_wrap_IModelVisualization_setLinkColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1878: flag=_wrap_IModelVisualization_resetLinkColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1879: flag=_wrap_IModelVisualization_getLinkNames(resc,resv,argc,(mxArray**)(argv)); break;
  case 1880: flag=_wrap_IModelVisualization_setLinkVisibility(resc,resv,argc,(mxArray**)(argv)); break;
  case 1881: flag=_wrap_IModelVisualization_getFeatures(resc,resv,argc,(mxArray**)(argv)); break;
  case 1882: flag=_wrap_IModelVisualization_setFeatureVisibility(resc,resv,argc,(mxArray**)(argv)); break;
  case 1883: flag=_wrap_IModelVisualization_jets(resc,resv,argc,(mxArray**)(argv)); break;
  case 1884: flag=_wrap_IModelVisualization_getWorldModelTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1885: flag=_wrap_IModelVisualization_getWorldLinkTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1886: flag=_wrap_delete_ITexture(resc,resv,argc,(mxArray**)(argv)); break;
  case 1887: flag=_wrap_ITexture_environment(resc,resv,argc,(mxArray**)(argv)); break;
  case 1888: flag=_wrap_ITexture_getPixelColor(resc,resv,argc,(mxArray**)(argv)); break;
  case 1889: flag=_wrap_ITexture_getPixels(resc,resv,argc,(mxArray**)(argv)); break;
  case 1890: flag=_wrap_VisualizerOptions_verbose_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1891: flag=_wrap_VisualizerOptions_verbose_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1892: flag=_wrap_VisualizerOptions_winWidth_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1893: flag=_wrap_VisualizerOptions_winWidth_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1894: flag=_wrap_VisualizerOptions_winHeight_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1895: flag=_wrap_VisualizerOptions_winHeight_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1896: flag=_wrap_VisualizerOptions_rootFrameArrowsDimension_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1897: flag=_wrap_VisualizerOptions_rootFrameArrowsDimension_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1898: flag=_wrap_new_VisualizerOptions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1899: flag=_wrap_delete_VisualizerOptions(resc,resv,argc,(mxArray**)(argv)); break;
  case 1900: flag=_wrap_delete_ITexturesHandler(resc,resv,argc,(mxArray**)(argv)); break;
  case 1901: flag=_wrap_ITexturesHandler_add(resc,resv,argc,(mxArray**)(argv)); break;
  case 1902: flag=_wrap_ITexturesHandler_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1903: flag=_wrap_new_Visualizer(resc,resv,argc,(mxArray**)(argv)); break;
  case 1904: flag=_wrap_delete_Visualizer(resc,resv,argc,(mxArray**)(argv)); break;
  case 1905: flag=_wrap_Visualizer_init(resc,resv,argc,(mxArray**)(argv)); break;
  case 1906: flag=_wrap_Visualizer_getNrOfVisualizedModels(resc,resv,argc,(mxArray**)(argv)); break;
  case 1907: flag=_wrap_Visualizer_getModelInstanceName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1908: flag=_wrap_Visualizer_getModelInstanceIndex(resc,resv,argc,(mxArray**)(argv)); break;
  case 1909: flag=_wrap_Visualizer_addModel(resc,resv,argc,(mxArray**)(argv)); break;
  case 1910: flag=_wrap_Visualizer_modelViz(resc,resv,argc,(mxArray**)(argv)); break;
  case 1911: flag=_wrap_Visualizer_camera(resc,resv,argc,(mxArray**)(argv)); break;
  case 1912: flag=_wrap_Visualizer_enviroment(resc,resv,argc,(mxArray**)(argv)); break;
  case 1913: flag=_wrap_Visualizer_vectors(resc,resv,argc,(mxArray**)(argv)); break;
  case 1914: flag=_wrap_Visualizer_frames(resc,resv,argc,(mxArray**)(argv)); break;
  case 1915: flag=_wrap_Visualizer_textures(resc,resv,argc,(mxArray**)(argv)); break;
  case 1916: flag=_wrap_Visualizer_run(resc,resv,argc,(mxArray**)(argv)); break;
  case 1917: flag=_wrap_Visualizer_draw(resc,resv,argc,(mxArray**)(argv)); break;
  case 1918: flag=_wrap_Visualizer_drawToFile(resc,resv,argc,(mxArray**)(argv)); break;
  case 1919: flag=_wrap_Visualizer_close(resc,resv,argc,(mxArray**)(argv)); break;
  case 1920: flag=_wrap_Visualizer_isWindowActive(resc,resv,argc,(mxArray**)(argv)); break;
  case 1921: flag=_wrap_Polygon_m_vertices_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1922: flag=_wrap_Polygon_m_vertices_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1923: flag=_wrap_new_Polygon(resc,resv,argc,(mxArray**)(argv)); break;
  case 1924: flag=_wrap_Polygon_setNrOfVertices(resc,resv,argc,(mxArray**)(argv)); break;
  case 1925: flag=_wrap_Polygon_getNrOfVertices(resc,resv,argc,(mxArray**)(argv)); break;
  case 1926: flag=_wrap_Polygon_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 1927: flag=_wrap_Polygon_applyTransform(resc,resv,argc,(mxArray**)(argv)); break;
  case 1928: flag=_wrap_Polygon_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 1929: flag=_wrap_Polygon_XYRectangleFromOffsets(resc,resv,argc,(mxArray**)(argv)); break;
  case 1930: flag=_wrap_delete_Polygon(resc,resv,argc,(mxArray**)(argv)); break;
  case 1931: flag=_wrap_Polygon2D_m_vertices_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1932: flag=_wrap_Polygon2D_m_vertices_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1933: flag=_wrap_new_Polygon2D(resc,resv,argc,(mxArray**)(argv)); break;
  case 1934: flag=_wrap_Polygon2D_setNrOfVertices(resc,resv,argc,(mxArray**)(argv)); break;
  case 1935: flag=_wrap_Polygon2D_getNrOfVertices(resc,resv,argc,(mxArray**)(argv)); break;
  case 1936: flag=_wrap_Polygon2D_isValid(resc,resv,argc,(mxArray**)(argv)); break;
  case 1937: flag=_wrap_Polygon2D_paren(resc,resv,argc,(mxArray**)(argv)); break;
  case 1938: flag=_wrap_delete_Polygon2D(resc,resv,argc,(mxArray**)(argv)); break;
  case 1939: flag=_wrap_ConvexHullProjectionConstraint_setActive(resc,resv,argc,(mxArray**)(argv)); break;
  case 1940: flag=_wrap_ConvexHullProjectionConstraint_isActive(resc,resv,argc,(mxArray**)(argv)); break;
  case 1941: flag=_wrap_ConvexHullProjectionConstraint_getNrOfConstraints(resc,resv,argc,(mxArray**)(argv)); break;
  case 1942: flag=_wrap_ConvexHullProjectionConstraint_projectedConvexHull_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1943: flag=_wrap_ConvexHullProjectionConstraint_projectedConvexHull_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1944: flag=_wrap_ConvexHullProjectionConstraint_A_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1945: flag=_wrap_ConvexHullProjectionConstraint_A_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1946: flag=_wrap_ConvexHullProjectionConstraint_b_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1947: flag=_wrap_ConvexHullProjectionConstraint_b_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1948: flag=_wrap_ConvexHullProjectionConstraint_P_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1949: flag=_wrap_ConvexHullProjectionConstraint_P_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1950: flag=_wrap_ConvexHullProjectionConstraint_Pdirection_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1951: flag=_wrap_ConvexHullProjectionConstraint_Pdirection_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1952: flag=_wrap_ConvexHullProjectionConstraint_AtimesP_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1953: flag=_wrap_ConvexHullProjectionConstraint_AtimesP_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1954: flag=_wrap_ConvexHullProjectionConstraint_o_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1955: flag=_wrap_ConvexHullProjectionConstraint_o_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1956: flag=_wrap_ConvexHullProjectionConstraint_buildConvexHull(resc,resv,argc,(mxArray**)(argv)); break;
  case 1957: flag=_wrap_ConvexHullProjectionConstraint_supportFrameIndices_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1958: flag=_wrap_ConvexHullProjectionConstraint_supportFrameIndices_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1959: flag=_wrap_ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_get(resc,resv,argc,(mxArray**)(argv)); break;
  case 1960: flag=_wrap_ConvexHullProjectionConstraint_absoluteFrame_X_supportFrame_set(resc,resv,argc,(mxArray**)(argv)); break;
  case 1961: flag=_wrap_ConvexHullProjectionConstraint_project(resc,resv,argc,(mxArray**)(argv)); break;
  case 1962: flag=_wrap_ConvexHullProjectionConstraint_computeMargin(resc,resv,argc,(mxArray**)(argv)); break;
  case 1963: flag=_wrap_ConvexHullProjectionConstraint_setProjectionAlongDirection(resc,resv,argc,(mxArray**)(argv)); break;
  case 1964: flag=_wrap_ConvexHullProjectionConstraint_projectAlongDirection(resc,resv,argc,(mxArray**)(argv)); break;
  case 1965: flag=_wrap_new_ConvexHullProjectionConstraint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1966: flag=_wrap_delete_ConvexHullProjectionConstraint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1967: flag=_wrap_sizeOfRotationParametrization(resc,resv,argc,(mxArray**)(argv)); break;
  case 1968: flag=_wrap_new_InverseKinematics(resc,resv,argc,(mxArray**)(argv)); break;
  case 1969: flag=_wrap_delete_InverseKinematics(resc,resv,argc,(mxArray**)(argv)); break;
  case 1970: flag=_wrap_InverseKinematics_loadModelFromFile(resc,resv,argc,(mxArray**)(argv)); break;
  case 1971: flag=_wrap_InverseKinematics_setModel(resc,resv,argc,(mxArray**)(argv)); break;
  case 1972: flag=_wrap_InverseKinematics_setJointLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 1973: flag=_wrap_InverseKinematics_getJointLimits(resc,resv,argc,(mxArray**)(argv)); break;
  case 1974: flag=_wrap_InverseKinematics_clearProblem(resc,resv,argc,(mxArray**)(argv)); break;
  case 1975: flag=_wrap_InverseKinematics_setFloatingBaseOnFrameNamed(resc,resv,argc,(mxArray**)(argv)); break;
  case 1976: flag=_wrap_InverseKinematics_setCurrentRobotConfiguration(resc,resv,argc,(mxArray**)(argv)); break;
  case 1977: flag=_wrap_InverseKinematics_setJointConfiguration(resc,resv,argc,(mxArray**)(argv)); break;
  case 1978: flag=_wrap_InverseKinematics_setRotationParametrization(resc,resv,argc,(mxArray**)(argv)); break;
  case 1979: flag=_wrap_InverseKinematics_rotationParametrization(resc,resv,argc,(mxArray**)(argv)); break;
  case 1980: flag=_wrap_InverseKinematics_setMaxIterations(resc,resv,argc,(mxArray**)(argv)); break;
  case 1981: flag=_wrap_InverseKinematics_maxIterations(resc,resv,argc,(mxArray**)(argv)); break;
  case 1982: flag=_wrap_InverseKinematics_setMaxCPUTime(resc,resv,argc,(mxArray**)(argv)); break;
  case 1983: flag=_wrap_InverseKinematics_maxCPUTime(resc,resv,argc,(mxArray**)(argv)); break;
  case 1984: flag=_wrap_InverseKinematics_setCostTolerance(resc,resv,argc,(mxArray**)(argv)); break;
  case 1985: flag=_wrap_InverseKinematics_costTolerance(resc,resv,argc,(mxArray**)(argv)); break;
  case 1986: flag=_wrap_InverseKinematics_setConstraintsTolerance(resc,resv,argc,(mxArray**)(argv)); break;
  case 1987: flag=_wrap_InverseKinematics_constraintsTolerance(resc,resv,argc,(mxArray**)(argv)); break;
  case 1988: flag=_wrap_InverseKinematics_setVerbosity(resc,resv,argc,(mxArray**)(argv)); break;
  case 1989: flag=_wrap_InverseKinematics_linearSolverName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1990: flag=_wrap_InverseKinematics_setLinearSolverName(resc,resv,argc,(mxArray**)(argv)); break;
  case 1991: flag=_wrap_InverseKinematics_addFrameConstraint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1992: flag=_wrap_InverseKinematics_addFramePositionConstraint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1993: flag=_wrap_InverseKinematics_addFrameRotationConstraint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1994: flag=_wrap_InverseKinematics_activateFrameConstraint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1995: flag=_wrap_InverseKinematics_deactivateFrameConstraint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1996: flag=_wrap_InverseKinematics_isFrameConstraintActive(resc,resv,argc,(mxArray**)(argv)); break;
  case 1997: flag=_wrap_InverseKinematics_addCenterOfMassProjectionConstraint(resc,resv,argc,(mxArray**)(argv)); break;
  case 1998: flag=_wrap_InverseKinematics_getCenterOfMassProjectionMargin(resc,resv,argc,(mxArray**)(argv)); break;
  case 1999: flag=_wrap_InverseKinematics_getCenterOfMassProjectConstraintConvexHull(resc,resv,argc,(mxArray**)(argv)); break;
  case 2000: flag=_wrap_InverseKinematics_addTarget(resc,resv,argc,(mxArray**)(argv)); break;
  case 2001: flag=_wrap_InverseKinematics_addPositionTarget(resc,resv,argc,(mxArray**)(argv)); break;
  case 2002: flag=_wrap_InverseKinematics_addRotationTarget(resc,resv,argc,(mxArray**)(argv)); break;
  case 2003: flag=_wrap_InverseKinematics_updateTarget(resc,resv,argc,(mxArray**)(argv)); break;
  case 2004: flag=_wrap_InverseKinematics_updatePositionTarget(resc,resv,argc,(mxArray**)(argv)); break;
  case 2005: flag=_wrap_InverseKinematics_updateRotationTarget(resc,resv,argc,(mxArray**)(argv)); break;
  case 2006: flag=_wrap_InverseKinematics_setDefaultTargetResolutionMode(resc,resv,argc,(mxArray**)(argv)); break;
  case 2007: flag=_wrap_InverseKinematics_defaultTargetResolutionMode(resc,resv,argc,(mxArray**)(argv)); break;
  case 2008: flag=_wrap_InverseKinematics_setTargetResolutionMode(resc,resv,argc,(mxArray**)(argv)); break;
  case 2009: flag=_wrap_InverseKinematics_targetResolutionMode(resc,resv,argc,(mxArray**)(argv)); break;
  case 2010: flag=_wrap_InverseKinematics_setDesiredFullJointsConfiguration(resc,resv,argc,(mxArray**)(argv)); break;
  case 2011: flag=_wrap_InverseKinematics_setDesiredReducedJointConfiguration(resc,resv,argc,(mxArray**)(argv)); break;
  case 2012: flag=_wrap_InverseKinematics_setFullJointsInitialCondition(resc,resv,argc,(mxArray**)(argv)); break;
  case 2013: flag=_wrap_InverseKinematics_setReducedInitialCondition(resc,resv,argc,(mxArray**)(argv)); break;
  case 2014: flag=_wrap_InverseKinematics_solve(resc,resv,argc,(mxArray**)(argv)); break;
  case 2015: flag=_wrap_InverseKinematics_getFullJointsSolution(resc,resv,argc,(mxArray**)(argv)); break;
  case 2016: flag=_wrap_InverseKinematics_getReducedSolution(resc,resv,argc,(mxArray**)(argv)); break;
  case 2017: flag=_wrap_InverseKinematics_getPoseForFrame(resc,resv,argc,(mxArray**)(argv)); break;
  case 2018: flag=_wrap_InverseKinematics_fullModel(resc,resv,argc,(mxArray**)(argv)); break;
  case 2019: flag=_wrap_InverseKinematics_reducedModel(resc,resv,argc,(mxArray**)(argv)); break;
  case 2020: flag=_wrap_InverseKinematics_setCOMTarget(resc,resv,argc,(mxArray**)(argv)); break;
  case 2021: flag=_wrap_InverseKinematics_setCOMAsConstraint(resc,resv,argc,(mxArray**)(argv)); break;
  case 2022: flag=_wrap_InverseKinematics_setCOMAsConstraintTolerance(resc,resv,argc,(mxArray**)(argv)); break;
  case 2023: flag=_wrap_InverseKinematics_isCOMAConstraint(resc,resv,argc,(mxArray**)(argv)); break;
  case 2024: flag=_wrap_InverseKinematics_isCOMTargetActive(resc,resv,argc,(mxArray**)(argv)); break;
  case 2025: flag=_wrap_InverseKinematics_deactivateCOMTarget(resc,resv,argc,(mxArray**)(argv)); break;
  case 2026: flag=_wrap_InverseKinematics_setCOMConstraintProjectionDirection(resc,resv,argc,(mxArray**)(argv)); break;
  default: flag=1, SWIG_Error(SWIG_RuntimeError, "No function id %d.", fcn_id);
  }
  if (flag) {
    mexErrMsgIdAndTxt(SWIG_ErrorType(SWIG_lasterror_code), SWIG_lasterror_msg);
  }
}
