tumble_wrap.C

Go to the documentation of this file.

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.21
 * 
 * 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. 
 * ----------------------------------------------------------------------------- */


#ifdef __cplusplus
template<class T> class SwigValueWrapper {
    T *tt;
public:
    SwigValueWrapper() : tt(0) { }
    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
    SwigValueWrapper(const T& t) : tt(new T(t)) { }
    ~SwigValueWrapper() { delete tt; } 
    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
    operator T&() const { return *tt; }
    T *operator&() { return tt; }
private:
    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
};                                                    
#endif

/* ruby.swg */
/* Implementation : RUBY */
#define SWIGRUBY 1

#include "ruby.h"

/* Flags for pointer conversion */
#define SWIG_POINTER_EXCEPTION     0x1
#define SWIG_POINTER_DISOWN        0x2

#define NUM2USHRT(n) (\
    (0 <= NUM2UINT(n) && NUM2UINT(n) <= USHRT_MAX)\
    ? (unsigned short) NUM2UINT(n) \
    : (rb_raise(rb_eArgError, "integer %d out of range of `unsigned short'",\
               NUM2UINT(n)), (short)0)\
)

#define NUM2SHRT(n) (\
    (SHRT_MIN <= NUM2INT(n) && NUM2INT(n) <= SHRT_MAX)\
    ? (short)NUM2INT(n)\
    : (rb_raise(rb_eArgError, "integer %d out of range of `short'",\
               NUM2INT(n)), (short)0)\
)

/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
#ifndef NUM2LL
#define NUM2LL(x) NUM2LONG((x))
#endif
#ifndef LL2NUM
#define LL2NUM(x) INT2NUM((long) (x))
#endif
#ifndef ULL2NUM
#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
#endif

/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
#ifndef NUM2ULL
#ifdef HAVE_LONG_LONG
#define NUM2ULL(x) rb_num2ull((x))
#else
#define NUM2ULL(x) NUM2ULONG(x)
#endif
#endif

/*
 * Need to be very careful about how these macros are defined, especially
 * when compiling C++ code or C code with an ANSI C compiler.
 *
 * VALUEFUNC(f) is a macro used to typecast a C function that implements
 * a Ruby method so that it can be passed as an argument to API functions
 * like rb_define_method() and rb_define_singleton_method().
 *
 * VOIDFUNC(f) is a macro used to typecast a C function that implements
 * either the "mark" or "free" stuff for a Ruby Data object, so that it
 * can be passed as an argument to API functions like Data_Wrap_Struct()
 * and Data_Make_Struct().
 */
 
#ifdef __cplusplus
#  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
#    define VALUEFUNC(f) ((VALUE (*)()) f)
#    define VOIDFUNC(f)  ((void (*)()) f)
#  else
#    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
#      define VALUEFUNC(f) ((VALUE (*)()) f)
#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
#    else /* These definitions should work for Ruby 1.7 */
#      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
#      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
#    endif
#  endif
#else
#  define VALUEFUNC(f) (f)
#  define VOIDFUNC(f) (f)
#endif

typedef struct {
  VALUE klass;
  VALUE mImpl;
  void  (*mark)(void *);
  void  (*destroy)(void *);
} swig_class;

/* Don't use for expressions have side effect */
#ifndef RB_STRING_VALUE
#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
#endif
#ifndef StringValue
#define StringValue(s) RB_STRING_VALUE(s)
#endif
#ifndef StringValuePtr
#define StringValuePtr(s) RSTRING(RB_STRING_VALUE(s))->ptr
#endif
#ifndef StringValueLen
#define StringValueLen(s) RSTRING(RB_STRING_VALUE(s))->len
#endif
#ifndef SafeStringValue
#define SafeStringValue(v) do {\
    StringValue(v);\
    rb_check_safe_str(v);\
} while (0)
#endif

#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
#endif

/* Contract support */

#define SWIG_contract_assert(expr, msg) if (!(expr)) { rb_raise(rb_eRuntimeError, (char *) msg ); } else


/*************************************************************** -*- c -*-
 * ruby/precommon.swg
 *
 * Rename all exported symbols from common.swg, to avoid symbol
 * clashes if multiple interpreters are included
 *
 ************************************************************************/

#define SWIG_TypeRegister    SWIG_Ruby_TypeRegister
#define SWIG_TypeCheck       SWIG_Ruby_TypeCheck
#define SWIG_TypeCast        SWIG_Ruby_TypeCast
#define SWIG_TypeDynamicCast SWIG_Ruby_TypeDynamicCast
#define SWIG_TypeName        SWIG_Ruby_TypeName
#define SWIG_TypeQuery       SWIG_Ruby_TypeQuery
#define SWIG_TypeClientData  SWIG_Ruby_TypeClientData
#define SWIG_PackData        SWIG_Ruby_PackData 
#define SWIG_UnpackData      SWIG_Ruby_UnpackData 

/* Also rename all exported symbols from rubydef.swig */

/* Common SWIG API */
#define SWIG_ConvertPtr(obj, pp, type, flags) \
  SWIG_Ruby_ConvertPtr(obj, pp, type, flags)
#define SWIG_NewPointerObj(p, type, flags) \
  SWIG_Ruby_NewPointerObj(p, type, flags)
#define SWIG_MustGetPtr(p, type, argnum, flags) \
  SWIG_Ruby_MustGetPtr(p, type, argnum, flags)

/* Ruby-specific SWIG API */

#define SWIG_InitRuntime() \
  SWIG_Ruby_InitRuntime()
#define SWIG_define_class(ty) \
  SWIG_Ruby_define_class(ty)
#define SWIG_NewClassInstance(value, ty) \
  SWIG_Ruby_NewClassInstance(value, ty)
#define SWIG_MangleStr(value) \
  SWIG_Ruby_MangleStr(value)
#define SWIG_CheckConvert(value, ty) \
  SWIG_Ruby_CheckConvert(value, ty)
#define SWIG_NewPackedObj(ptr, sz, ty) \
  SWIG_Ruby_NewPackedObj(ptr, sz, ty)
#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) \
  SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)


/***********************************************************************
 * common.swg
 *
 *     This file contains generic SWIG runtime support for pointer
 *     type checking as well as a few commonly used macros to control
 *     external linkage.
 *
 * Author : David Beazley (beazley@cs.uchicago.edu)
 *
 * Copyright (c) 1999-2000, The University of Chicago
 * 
 * This file may be freely redistributed without license or fee provided
 * this copyright message remains intact.
 ************************************************************************/

#include <string.h>

#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#  if defined(_MSC_VER) || defined(__GNUC__)
#    if defined(STATIC_LINKED)
#      define SWIGEXPORT(a) a
#      define SWIGIMPORT(a) extern a
#    else
#      define SWIGEXPORT(a) __declspec(dllexport) a
#      define SWIGIMPORT(a) extern a
#    endif
#  else
#    if defined(__BORLANDC__)
#      define SWIGEXPORT(a) a _export
#      define SWIGIMPORT(a) a _export
#    else
#      define SWIGEXPORT(a) a
#      define SWIGIMPORT(a) a
#    endif
#  endif
#else
#  define SWIGEXPORT(a) a
#  define SWIGIMPORT(a) a
#endif

#ifdef SWIG_GLOBAL
#  define SWIGRUNTIME(a) SWIGEXPORT(a)
#else
#  define SWIGRUNTIME(a) static a
#endif

#ifdef __cplusplus
extern "C" {
#endif

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

typedef struct swig_type_info {
  const char             *name;
  swig_converter_func     converter;
  const char             *str;
  void                   *clientdata;
  swig_dycast_func        dcast;
  struct swig_type_info  *next;
  struct swig_type_info  *prev;
} swig_type_info;

#ifdef SWIG_NOINCLUDE

SWIGIMPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
SWIGIMPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
SWIGIMPORT(void *)           SWIG_TypeCast(swig_type_info *, void *);
SWIGIMPORT(swig_type_info *) SWIG_TypeDynamicCast(swig_type_info *, void **);
SWIGIMPORT(const char *)     SWIG_TypeName(const swig_type_info *);
SWIGIMPORT(swig_type_info *) SWIG_TypeQuery(const char *);
SWIGIMPORT(void)             SWIG_TypeClientData(swig_type_info *, void *);
SWIGIMPORT(char *)           SWIG_PackData(char *, void *, int);
SWIGIMPORT(char *)           SWIG_UnpackData(char *, void *, int);

#else

static swig_type_info *swig_type_list = 0;

/* Register a type mapping with the type-checking */
SWIGRUNTIME(swig_type_info *)
SWIG_TypeRegister(swig_type_info *ti) {
  swig_type_info *tc, *head, *ret, *next;
  /* Check to see if this type has already been registered */
  tc = swig_type_list;
  while (tc) {
    if (strcmp(tc->name, ti->name) == 0) {
      /* Already exists in the table.  Just add additional types to the list */
      if (tc->clientdata) ti->clientdata = tc->clientdata;
      head = tc;
      next = tc->next;
      goto l1;
    }
    tc = tc->prev;
  }
  head = ti;
  next = 0;

  /* Place in list */
  ti->prev = swig_type_list;
  swig_type_list = ti;

  /* Build linked lists */
  l1:
  ret = head;
  tc = ti + 1;
  /* Patch up the rest of the links */
  while (tc->name) {
    head->next = tc;
    tc->prev = head;
    head = tc;
    tc++;
  }
  if (next) next->prev = head;
  head->next = next;
  return ret;
}

/* Check the typename */
SWIGRUNTIME(swig_type_info *) 
SWIG_TypeCheck(char *c, swig_type_info *ty) {
  swig_type_info *s;
  if (!ty) return 0;        /* Void pointer */
  s = ty->next;             /* First element always just a name */
  do {
    if (strcmp(s->name,c) == 0) {
      if (s == ty->next) return s;
      /* Move s to the top of the linked list */
      s->prev->next = s->next;
      if (s->next) {
        s->next->prev = s->prev;
      }
      /* Insert s as second element in the list */
      s->next = ty->next;
      if (ty->next) ty->next->prev = s;
      ty->next = s;
      s->prev = ty;
      return s;
    }
    s = s->next;
  } while (s && (s != ty->next));
  return 0;
}

/* Cast a pointer up an inheritance hierarchy */
SWIGRUNTIME(void *) 
SWIG_TypeCast(swig_type_info *ty, void *ptr) {
  if ((!ty) || (!ty->converter)) return ptr;
  return (*ty->converter)(ptr);
}

/* 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 */
SWIGRUNTIME(const char *)
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/* Search for a swig_type_info structure */
SWIGRUNTIME(swig_type_info *)
SWIG_TypeQuery(const char *name) {
  swig_type_info *ty = swig_type_list;
  while (ty) {
    if (ty->str && (strcmp(name,ty->str) == 0)) return ty;
    if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
    ty = ty->prev;
  }
  return 0;
}

/* Set the clientdata field for a type */
SWIGRUNTIME(void)
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_type_info *tc, *equiv;
  if (ti->clientdata == clientdata) return;
  ti->clientdata = clientdata;
  equiv = ti->next;
  while (equiv) {
    if (!equiv->converter) {
      tc = swig_type_list;
      while (tc) {
        if ((strcmp(tc->name, equiv->name) == 0))
          SWIG_TypeClientData(tc,clientdata);
        tc = tc->prev;
      }
    }
    equiv = equiv->next;
  }
}

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

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

#endif

#ifdef __cplusplus
}
#endif

/* rubydef.swg */
#ifdef __cplusplus
extern "C" {
#endif

static VALUE _mSWIG = Qnil;
static VALUE _cSWIG_Pointer = Qnil;

/* Initialize Ruby runtime support */
SWIGRUNTIME(void)
SWIG_Ruby_InitRuntime(void)
{
    if (_mSWIG == Qnil) {
        _mSWIG = rb_define_module("SWIG");
    }
}

/* Define Ruby class for C type */
SWIGRUNTIME(void)
SWIG_Ruby_define_class(swig_type_info *type)
{
    VALUE klass;
    char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
    sprintf(klass_name, "TYPE%s", type->name);
    if (NIL_P(_cSWIG_Pointer)) {
    _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
    rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
    }
    klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
    free((void *) klass_name);
}

/* Create a new pointer object */
SWIGRUNTIME(VALUE)
SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int own)
{
    char *klass_name;
    swig_class *sklass;
    VALUE klass;
    VALUE obj;
    
    if (!ptr)
    return Qnil;
    
    if (type->clientdata) {
      sklass = (swig_class *) type->clientdata;
      obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr);
    } else {
      klass_name = (char *) malloc(4 + strlen(type->name) + 1);
      sprintf(klass_name, "TYPE%s", type->name);
      klass = rb_const_get(_mSWIG, rb_intern(klass_name));
      free((void *) klass_name);
      obj = Data_Wrap_Struct(klass, 0, 0, ptr);
    }
    rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
    return obj;
}

/* Create a new class instance (always owned) */
SWIGRUNTIME(VALUE)
SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
{
    VALUE obj;
    swig_class *sklass = (swig_class *) type->clientdata;
    obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
    rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
    return obj;
}

/* Get type mangle from class name */
SWIGRUNTIME(char *)
SWIG_Ruby_MangleStr(VALUE obj)
{
  VALUE stype = rb_iv_get(obj, "__swigtype__");
  return StringValuePtr(stype);
}

/* Convert a pointer value */
SWIGRUNTIME(int)
SWIG_Ruby_ConvertPtr(VALUE obj, void **ptr, swig_type_info *ty, int flags)
{
  char *c;
  swig_type_info *tc;

  /* Grab the pointer */
  if (NIL_P(obj)) {
    *ptr = 0;
    return 0;
  } else {
    Data_Get_Struct(obj, void, *ptr);
  }
  
  /* Do type-checking if type info was provided */
  if (ty) {
    if (ty->clientdata) {
        if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
          if (*ptr == 0)
            rb_raise(rb_eRuntimeError, "This %s already released", ty->str);
          return 0;
        }
    }
    if ((c = SWIG_MangleStr(obj)) == NULL) {
      if (flags & SWIG_POINTER_EXCEPTION)
        rb_raise(rb_eTypeError, "Expected %s", ty->str);
      else
        return -1;
    }
    tc = SWIG_TypeCheck(c, ty);
    if (!tc) {
      if (flags & SWIG_POINTER_EXCEPTION)
        rb_raise(rb_eTypeError, "Expected %s", ty->str);
      else
        return -1;
    }
    *ptr = SWIG_TypeCast(tc, *ptr);
  }
  return 0;
}

/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME(void *)
SWIG_Ruby_MustGetPtr(VALUE obj, swig_type_info *ty, int argnum, int flags)
{
  void *result;
  SWIG_ConvertPtr(obj, &result, ty, flags | SWIG_POINTER_EXCEPTION);
  return result;
}

/* Check convert */
SWIGRUNTIME(int)
SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
{
  char *c = SWIG_MangleStr(obj);
  if (!c)
    return 0;
  return SWIG_TypeCheck(c,ty) != 0;
}

SWIGRUNTIME(VALUE)
SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
  char result[1024];
  char *r = result;
  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r, ptr, sz);
  strcpy(r, type->name);
  return rb_str_new2(result);
}

/* Convert a packed value value */
SWIGRUNTIME(void)
SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty, int flags) {
  swig_type_info *tc;
  char  *c;

  if (TYPE(obj) != T_STRING) goto type_error;
  c = StringValuePtr(obj);
  /* Pointer values must start with leading underscore */
  if (*c != '_') goto type_error;
  c++;
  c = SWIG_UnpackData(c, ptr, sz);
  if (ty) {
    tc = SWIG_TypeCheck(c, ty);
    if (!tc) goto type_error;
  }
  return;

type_error:

  if (flags) {
    if (ty) {
      rb_raise(rb_eTypeError, "Type error. Expected %s", ty->name);
    } else {
      rb_raise(rb_eTypeError, "Expected a pointer");
    }
  }
}

#ifdef __cplusplus
}
#endif



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

#define  SWIGTYPE_p_GrayscaleMap swig_types[0] 
#define  SWIGTYPE_p_Cell swig_types[1] 
#define  SWIGTYPE_p_ControlPoint swig_types[2] 
#define  SWIGTYPE_p_hash_setTBoundaryFace_p_CellHasherTBoundaryFace_t_CellEqualTBoundaryFace_t_t swig_types[3] 
#define  SWIGTYPE_p_BoundaryFace swig_types[4] 
#define  SWIGTYPE_p_Color swig_types[5] 
#define  SWIGTYPE_p_Pump swig_types[6] 
#define  SWIGTYPE_p_hash_mapTlistTPoint2D_t__iterator_listTLinearData_t__iterator_ControlPointHasher_ControlPointEqual_t swig_types[7] 
#define  SWIGTYPE_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t swig_types[8] 
#define  SWIGTYPE_p_SlitCavity swig_types[9] 
#define  SWIGTYPE_p_hash_setTBezierEdge_p_CellHasherTBezierEdge_t_CellEqualTBezierEdge_t_t swig_types[10] 
#define  SWIGTYPE_p_BezierVertex swig_types[11] 
#define  SWIGTYPE_p_hash_setTBezierVertex_p_CellHasherTBezierVertex_t_CellEqualTBezierVertex_t_t swig_types[12] 
#define  SWIGTYPE_p_Simulation swig_types[13] 
#define  SWIGTYPE_p_Visualization swig_types[14] 
#define  SWIGTYPE_p_PSCoord swig_types[15] 
#define  SWIGTYPE_p_vectorTlistTPoint2D_t__iterator_t swig_types[16] 
#define  SWIGTYPE_p_hash_setTBoundaryVertex_p_CellHasherTBoundaryVertex_t_CellEqualTBoundaryVertex_t_t swig_types[17] 
#define  SWIGTYPE_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t swig_types[18] 
#define  SWIGTYPE_p_FaceCell swig_types[19] 
#define  SWIGTYPE_p_MeshConstructor swig_types[20] 
#define  SWIGTYPE_p_Point2D swig_types[21] 
#define  SWIGTYPE_p_p_void swig_types[22] 
#define  SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t swig_types[23] 
#define  SWIGTYPE_p_double swig_types[24] 
#define  SWIGTYPE_p_p_double swig_types[25] 
#define  SWIGTYPE_p_int swig_types[26] 
#define  SWIGTYPE_p_MeshInput swig_types[27] 
#define  SWIGTYPE_p_VertexCell swig_types[28] 
#define  SWIGTYPE_p_dequeTBezierTriangle_p_t swig_types[29] 
#define  SWIGTYPE_p_listTBezierTriangle_p_t swig_types[30] 
#define  SWIGTYPE_p_vectorTBezierTriangle_p_t swig_types[31] 
#define  SWIGTYPE_p_LinearData swig_types[32] 
#define  SWIGTYPE_p_EdgeCell swig_types[33] 
#define  SWIGTYPE_p_p_BezierEdge swig_types[34] 
#define  SWIGTYPE_p_BezierEdge swig_types[35] 
#define  SWIGTYPE_p_DataPoint swig_types[36] 
#define  SWIGTYPE_p_hash_setTBezierTriangle_p_CellHasherTBezierTriangle_t_CellEqualTBezierTriangle_t_t swig_types[37] 
#define  SWIGTYPE_p_vectorTdouble_t swig_types[38] 
#define  SWIGTYPE_p_Matrix5 swig_types[39] 
#define  SWIGTYPE_p_TimeKeeper swig_types[40] 
#define  SWIGTYPE_p_QBSpline swig_types[41] 
#define  SWIGTYPE_p_ColorMap swig_types[42] 
#define  SWIGTYPE_p_MeshOutput swig_types[43] 
#define  SWIGTYPE_p_dequeTBoundaryFace_p_t swig_types[44] 
#define  SWIGTYPE_p_listTBoundaryFace_p_t swig_types[45] 
#define  SWIGTYPE_p_vectorTBoundaryFace_p_t swig_types[46] 
#define  SWIGTYPE_p_BezierMesh swig_types[47] 
#define  SWIGTYPE_p_hash_setTBoundaryEdge_p_CellHasherTBoundaryEdge_t_CellEqualTBoundaryEdge_t_t swig_types[48] 
#define  SWIGTYPE_p_p_BoundaryEdge swig_types[49] 
#define  SWIGTYPE_p_BoundaryEdge swig_types[50] 
#define  SWIGTYPE_p_BezierTuple swig_types[51] 
#define  SWIGTYPE_p_listTBoundaryVertex_p_t swig_types[52] 
#define  SWIGTYPE_p_vectorTBoundaryVertex_p_t swig_types[53] 
#define  SWIGTYPE_p_listTBezierVertex_p_t swig_types[54] 
#define  SWIGTYPE_p_vectorTBezierVertex_p_t swig_types[55] 
#define  SWIGTYPE_p_vectorTPoint2D_t swig_types[56] 
#define  SWIGTYPE_p_listTPoint2D_t swig_types[57] 
#define  SWIGTYPE_p_BoundaryVertex swig_types[58] 
#define  SWIGTYPE_p_PSDrawMode swig_types[59] 
#define  SWIGTYPE_p_Matrix swig_types[60] 
#define  SWIGTYPE_p_BoundaryMesh swig_types[61] 
#define  SWIGTYPE_p_EPSWrite swig_types[62] 
#define  SWIGTYPE_p_float swig_types[63] 
#define  SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t swig_types[64] 
#define  SWIGTYPE_p_listTLinearData_t swig_types[65] 
#define  SWIGTYPE_p_dequeTBoundaryEdge_p_t swig_types[66] 
#define  SWIGTYPE_p_listTBoundaryEdge_p_t swig_types[67] 
#define  SWIGTYPE_p_vectorTBoundaryEdge_p_t swig_types[68] 
#define  SWIGTYPE_p_dequeTBezierEdge_p_t swig_types[69] 
#define  SWIGTYPE_p_listTBezierEdge_p_t swig_types[70] 
#define  SWIGTYPE_p_vectorTBezierEdge_p_t swig_types[71] 
#define  SWIGTYPE_p_p_BezierTriangle swig_types[72] 
#define  SWIGTYPE_p_CurvedTriangle swig_types[73] 
#define  SWIGTYPE_p_BezierTriangle swig_types[74] 
#define  SWIGTYPE_p_GhostTriangle swig_types[75] 
#define  SWIGTYPE_p_BoundaryTuple swig_types[76] 
static swig_type_info *swig_types[78];

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

#define SWIG_init    Init_Tumble
#define SWIG_name    "Tumble"

static VALUE mTumble;

#include "inc/globals.h"
#include "inc/util.h"
#include <ext/hash_set>
#include <ext/hash_map>
#include "inc/cell.h"
#include "inc/beziermesh.h"
#include "inc/boundarymesh.h"
#include "inc/spline.h"
#include "inc/meshio.h"
#include "inc/simulation.h"
#include "inc/visualization.h"
#include "inc/color.h"
#include "inc/epswrite.h"
#include "inc/meshconstructor.h"
#include "inc/pump.h"
#include "inc/slitcavity.h"


#ifdef __cplusplus
extern "C" {
#endif
#ifdef HAVE_SYS_TIME_H
# include <sys/time.h>
struct timeval rb_time_timeval(VALUE);
#endif
#ifdef __cplusplus
}
#endif


#ifdef __cplusplus
extern "C" {
#endif
#include "rubyio.h"
#ifdef __cplusplus
}
#endif

extern double const ALPHA[7];
extern double const BETA[7];
extern double const WEIGHT[7];
extern double const PI;
extern double const TWOPI;
extern double const HALFPI;

swig_class cPoint2D;
static void free_Point2D(Point2D *);

swig_class cLinearData;
static void free_LinearData(LinearData *);

swig_class cMatrix;
static void free_Matrix(Matrix *);

swig_class cMatrix5;
static void free_Matrix5(Matrix5 *);

swig_class cCell;
static void free_Cell(Cell *);

swig_class cVertexCell;
static void free_VertexCell(VertexCell *);

swig_class cEdgeCell;
static void free_EdgeCell(EdgeCell *);

swig_class cFaceCell;
static void free_FaceCell(FaceCell *);

swig_class cBoundaryVertex;
static void free_BoundaryVertex(BoundaryVertex *);

swig_class cBoundaryEdge;
static void free_BoundaryEdge(BoundaryEdge *);

swig_class cBoundaryFace;
static void free_BoundaryFace(BoundaryFace *);

swig_class cBezierVertex;
static void free_BezierVertex(BezierVertex *);

swig_class cBezierEdge;
static void free_BezierEdge(BezierEdge *);
extern double const newton_optimal_tolerance;
extern double const newton_zero_tolerance;
extern double const newton_tolerance;
extern unsigned int const newton_iterations;

swig_class cCurvedTriangle;
static void free_CurvedTriangle(CurvedTriangle *);

swig_class cBezierTriangle;
static void free_BezierTriangle(BezierTriangle *);

swig_class cGhostTriangle;
static void free_GhostTriangle(GhostTriangle *);

swig_class cBezierTuple;
static void free_CellTuplelBezierVertexcBezierEdgecBezierTriangle_g___(CellTuple<BezierVertex,BezierEdge,BezierTriangle > *);

swig_class cBoundaryTuple;
static void free_CellTuplelBoundaryVertexcBoundaryEdgecBoundaryFace_g___(CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *);

swig_class cQBSpline;
static void free_QBSpline(QBSpline *);

swig_class cBezierComplex;
static void free_CellComplexlBezierVertexcBezierEdgecBezierTrianglecBezierTuple_g___(CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *);

swig_class cBoundaryComplex;
static void free_CellComplexlBoundaryVertexcBoundaryEdgecBoundaryFacecBoundaryTuple_g___(CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *);

swig_class cBoundaryMesh;
static void free_BoundaryMesh(BoundaryMesh *);

swig_class cBezierMesh;
static void free_BezierMesh(BezierMesh *);

swig_class cMeshInput;
static void free_MeshInput(MeshInput *);

swig_class cMeshOutput;
static void free_MeshOutput(MeshOutput *);

swig_class cSimulation;
static void free_Simulation(Simulation *);

swig_class cVisualization;
static void free_Visualization(Visualization *);

swig_class cColor;
static void free_Color(Color *);

swig_class cPSCoord;
static void free_PSCoord(PSCoord *);

swig_class cPSDrawMode;
static void free_PSDrawMode(PSDrawMode *);

swig_class cEPSWrite;
static void free_EPSWrite(EPSWrite *);

swig_class cMeshConstructor;
static void free_MeshConstructor(MeshConstructor *);

swig_class cPump;
static void free_Pump(Pump *);

swig_class cSlitCavity;
static void free_SlitCavity(SlitCavity *);
static VALUE
ALPHA_get(VALUE self) {
    VALUE _val;
    
    _val = SWIG_NewPointerObj((void *) ALPHA, SWIGTYPE_p_double,0);    return _val;
}


static VALUE
BETA_get(VALUE self) {
    VALUE _val;
    
    _val = SWIG_NewPointerObj((void *) BETA, SWIGTYPE_p_double,0);    return _val;
}


static VALUE
WEIGHT_get(VALUE self) {
    VALUE _val;
    
    _val = SWIG_NewPointerObj((void *) WEIGHT, SWIGTYPE_p_double,0);    return _val;
}


static VALUE
PI_get(VALUE self) {
    VALUE _val;
    
    _val = rb_float_new(PI);    return _val;
}


static VALUE
TWOPI_get(VALUE self) {
    VALUE _val;
    
    _val = rb_float_new(TWOPI);    return _val;
}


static VALUE
HALFPI_get(VALUE self) {
    VALUE _val;
    
    _val = rb_float_new(HALFPI);    return _val;
}


static VALUE
_wrap_Point2D_coords_set(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    double *arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_double, 1);
    {
        int ii;
        double *b = (double *) arg1->coords;
        for (ii = 0; ii < 2; ii++) b[ii] = *((double *) arg2 + ii);
    }
    return Qnil;
}


static VALUE
_wrap_Point2D_coords_get(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    double *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    result = (double *)(double *) ((arg1)->coords);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_double,0);
    return vresult;
}


static VALUE
_wrap_new_Point2D__SWIG_0(int argc, VALUE *argv, VALUE self) {
    Point2D *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (Point2D *)new Point2D();
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_Point2D__SWIG_1(int argc, VALUE *argv, VALUE self) {
    double arg1 ;
    double arg2 ;
    Point2D *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg1 = (double) NUM2DBL(argv[0]);
    arg2 = (double) NUM2DBL(argv[1]);
    result = (Point2D *)new Point2D(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Point2D_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Point2D_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Point2D);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Point2D__SWIG_2(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = 0 ;
    Point2D *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_Point2D, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (Point2D *)new Point2D((Point2D const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_Point2D(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[2];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_Point2D__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Point2D, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_Point2D__SWIG_2(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FLOAT) || (TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FLOAT) || (TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_Point2D__SWIG_1(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_Point2D'");
    return Qnil;
}


static VALUE
_wrap_Point2D_assign(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    double arg2 ;
    double arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    (arg1)->assign(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_Point2D_at(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    int arg2 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    arg2 = NUM2INT(argv[0]);
    result = (double)((Point2D const *)arg1)->operator [](arg2);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Point2D_x(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    result = (double)((Point2D const *)arg1)->x();
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Point2D_y(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    result = (double)((Point2D const *)arg1)->y();
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Point2D___eq__(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    Point2D *arg2 = 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (bool)((Point2D const *)arg1)->operator ==((Point2D const &)*arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Point2D___lt__(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    Point2D *arg2 = 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (bool)((Point2D const *)arg1)->operator <((Point2D const &)*arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Point2D___le__(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    Point2D *arg2 = 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (bool)((Point2D const *)arg1)->operator <=((Point2D const &)*arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Point2D___gt__(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    Point2D *arg2 = 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (bool)((Point2D const *)arg1)->operator >((Point2D const &)*arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Point2D___ge__(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    Point2D *arg2 = 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (bool)((Point2D const *)arg1)->operator >=((Point2D const &)*arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Point2D___add__(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    Point2D *arg2 = 0 ;
    Point2D result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = ((Point2D const *)arg1)->operator +((Point2D const &)*arg2);
    
    {
        Point2D * resultptr;
        resultptr = new Point2D((Point2D &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Point2D, 1);
    }
    return vresult;
}


static VALUE
_wrap_Point2D___sub__(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    Point2D *arg2 = 0 ;
    Point2D result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = ((Point2D const *)arg1)->operator -((Point2D const &)*arg2);
    
    {
        Point2D * resultptr;
        resultptr = new Point2D((Point2D &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Point2D, 1);
    }
    return vresult;
}


static VALUE
_wrap_Point2D___mul__(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    double arg2 ;
    Point2D result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    result = ((Point2D const *)arg1)->operator *(arg2);
    
    {
        Point2D * resultptr;
        resultptr = new Point2D((Point2D &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Point2D, 1);
    }
    return vresult;
}


static VALUE
_wrap_Point2D___div__(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    double arg2 ;
    Point2D result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    result = ((Point2D const *)arg1)->operator /(arg2);
    
    {
        Point2D * resultptr;
        resultptr = new Point2D((Point2D &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Point2D, 1);
    }
    return vresult;
}


static VALUE
_wrap_Point2D_dot(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    Point2D *arg2 = 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (double)((Point2D const *)arg1)->dot((Point2D const &)*arg2);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Point2D_magsq(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    result = (double)((Point2D const *)arg1)->magsq();
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Point2D_mag(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    result = (double)((Point2D const *)arg1)->mag();
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Point2D_cross(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    Point2D *arg2 = 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (double)((Point2D const *)arg1)->cross((Point2D const &)*arg2);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Point2D_is_left_of(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    Point2D *arg2 = 0 ;
    Point2D *arg3 = 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Point2D, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (bool)((Point2D const *)arg1)->is_left_of((Point2D const &)*arg2,(Point2D const &)*arg3);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Point2D_is_right_of(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    Point2D *arg2 = 0 ;
    Point2D *arg3 = 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Point2D, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (bool)((Point2D const *)arg1)->is_right_of((Point2D const &)*arg2,(Point2D const &)*arg3);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Point2D_line_side_test(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    Point2D *arg2 = 0 ;
    Point2D *arg3 = 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Point2D, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (double)((Point2D const *)arg1)->line_side_test((Point2D const &)*arg2,(Point2D const &)*arg3);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Point2D_in_circle_test(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    Point2D arg2 ;
    Point2D arg3 ;
    Point2D arg4 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    {
        Point2D * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_Point2D, 1);
        if (ptr) arg2 = *ptr;
    }
    {
        Point2D * ptr;
        SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_Point2D, 1);
        if (ptr) arg3 = *ptr;
    }
    {
        Point2D * ptr;
        SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_Point2D, 1);
        if (ptr) arg4 = *ptr;
    }
    result = (bool)((Point2D const *)arg1)->in_circle_test(arg2,arg3,arg4);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Point2D_dist_from_line(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    Point2D *arg2 = 0 ;
    Point2D *arg3 = 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Point2D, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (double)((Point2D const *)arg1)->dist_from_line((Point2D const &)*arg2,(Point2D const &)*arg3);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Point2D_print(int argc, VALUE *argv, VALUE self) {
    Point2D *arg1 = (Point2D *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Point2D, 1);
    (arg1)->print();
    
    return Qnil;
}


static void
free_Point2D(Point2D *arg1) {
    delete arg1;
}
static VALUE
_wrap_LinearData_fields_set(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    double *arg2 = (double *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_double, 1);
    if (arg1) (arg1)->fields = arg2;
    
    return Qnil;
}


static VALUE
_wrap_LinearData_fields_get(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    double *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    result = (double *) ((arg1)->fields);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_double,0);
    return vresult;
}


static VALUE
_wrap_LinearData_length_set(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->length = arg2;
    
    return Qnil;
}


static VALUE
_wrap_LinearData_length_get(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    result = (int) ((arg1)->length);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_new_LinearData__SWIG_0(int argc, VALUE *argv, VALUE self) {
    LinearData *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (LinearData *)new LinearData();
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_LinearData__SWIG_1(int argc, VALUE *argv, VALUE self) {
    int arg1 ;
    LinearData *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    arg1 = NUM2INT(argv[0]);
    result = (LinearData *)new LinearData(arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_LinearData__SWIG_2(int argc, VALUE *argv, VALUE self) {
    double *arg1 = (double *) 0 ;
    int arg2 ;
    LinearData *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_double, 1);
    arg2 = NUM2INT(argv[1]);
    result = (LinearData *)new LinearData(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_LinearData__SWIG_3(int argc, VALUE *argv, VALUE self) {
    vector<double > *arg1 = 0 ;
    LinearData *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_vectorTdouble_t, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (LinearData *)new LinearData((vector<double > const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_LinearData_allocate(VALUE self) {
#else
    static VALUE
    _wrap_LinearData_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_LinearData);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_LinearData__SWIG_4(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = 0 ;
    LinearData *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_LinearData, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (LinearData *)new LinearData((LinearData const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_LinearData(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[2];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_LinearData__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_vectorTdouble_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_LinearData__SWIG_3(nargs, args, self);
        }
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_LinearData, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_LinearData__SWIG_4(nargs, args, self);
        }
    }
    if (argc == 1) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_LinearData__SWIG_1(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_double, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_LinearData__SWIG_2(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_LinearData'");
    return Qnil;
}


static void
free_LinearData(LinearData *arg1) {
    delete arg1;
}
static VALUE
_wrap_LinearData_update__SWIG_0(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    vector<double > *arg2 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTdouble_t, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->update((vector<double > const &)*arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_LinearData_update__SWIG_1(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    double *arg2 = (double *) 0 ;
    int arg3 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_double, 1);
    arg3 = NUM2INT(argv[1]);
    result = (int)(arg1)->update(arg2,arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE _wrap_LinearData_update(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_LinearData, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_vectorTdouble_t, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_LinearData_update__SWIG_0(nargs, args, self);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_LinearData, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_double, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_LinearData_update__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'LinearData_update'");
    return Qnil;
}


static VALUE
_wrap_LinearData_zero(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    (arg1)->zero();
    
    return Qnil;
}


static VALUE
_wrap_LinearData_set(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    double arg2 ;
    int arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = NUM2INT(argv[1]);
    (arg1)->set(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_LinearData_at(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    int arg2 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    arg2 = NUM2INT(argv[0]);
    result = (double)((LinearData const *)arg1)->operator [](arg2);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_LinearData_get(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    int arg2 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    arg2 = NUM2INT(argv[0]);
    result = (double)((LinearData const *)arg1)->get(arg2);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_LinearData___add__(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    LinearData *arg2 = 0 ;
    LinearData result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_LinearData, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = ((LinearData const *)arg1)->operator +((LinearData const &)*arg2);
    
    {
        LinearData * resultptr;
        resultptr = new LinearData((LinearData &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_LinearData, 1);
    }
    return vresult;
}


static VALUE
_wrap_LinearData___sub__(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    LinearData *arg2 = 0 ;
    LinearData result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_LinearData, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = ((LinearData const *)arg1)->operator -((LinearData const &)*arg2);
    
    {
        LinearData * resultptr;
        resultptr = new LinearData((LinearData &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_LinearData, 1);
    }
    return vresult;
}


static VALUE
_wrap_LinearData___mul__(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    double arg2 ;
    LinearData result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    result = ((LinearData const *)arg1)->operator *(arg2);
    
    {
        LinearData * resultptr;
        resultptr = new LinearData((LinearData &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_LinearData, 1);
    }
    return vresult;
}


static VALUE
_wrap_LinearData___div__(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    double arg2 ;
    LinearData result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    result = ((LinearData const *)arg1)->operator /(arg2);
    
    {
        LinearData * resultptr;
        resultptr = new LinearData((LinearData &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_LinearData, 1);
    }
    return vresult;
}


static VALUE
_wrap_LinearData_print(int argc, VALUE *argv, VALUE self) {
    LinearData *arg1 = (LinearData *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_LinearData, 1);
    (arg1)->print();
    
    return Qnil;
}


static VALUE
_wrap_Matrix_m_set(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = (Matrix *) 0 ;
    double **arg2 = (double **) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_p_double, 1);
    if (arg1) (arg1)->m = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Matrix_m_get(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = (Matrix *) 0 ;
    double **result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix, 1);
    result = (double **) ((arg1)->m);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_p_double,0);
    return vresult;
}


static VALUE
_wrap_Matrix_rows_set(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = (Matrix *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->rows = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Matrix_rows_get(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = (Matrix *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix, 1);
    result = (int) ((arg1)->rows);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Matrix_cols_set(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = (Matrix *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->cols = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Matrix_cols_get(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = (Matrix *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix, 1);
    result = (int) ((arg1)->cols);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_new_Matrix__SWIG_0(int argc, VALUE *argv, VALUE self) {
    int arg1 ;
    int arg2 ;
    Matrix *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg1 = NUM2INT(argv[0]);
    arg2 = NUM2INT(argv[1]);
    result = (Matrix *)new Matrix(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Matrix_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Matrix_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Matrix);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Matrix__SWIG_1(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = 0 ;
    Matrix *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_Matrix, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (Matrix *)new Matrix((Matrix const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_Matrix(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[2];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Matrix, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_Matrix__SWIG_1(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_Matrix__SWIG_0(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_Matrix'");
    return Qnil;
}


static void
free_Matrix(Matrix *arg1) {
    delete arg1;
}
static VALUE
_wrap_Matrix___call__(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = (Matrix *) 0 ;
    int arg2 ;
    int arg3 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    result = (double)((Matrix const *)arg1)->operator ()(arg2,arg3);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Matrix_set(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = (Matrix *) 0 ;
    int arg2 ;
    int arg3 ;
    double arg4 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    arg4 = (double) NUM2DBL(argv[2]);
    (arg1)->set(arg2,arg3,arg4);
    
    return Qnil;
}


static VALUE
_wrap_Matrix_det(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = (Matrix *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix, 1);
    result = (double)(arg1)->det();
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Matrix_transpose_times_self(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = (Matrix *) 0 ;
    Matrix *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix, 1);
    result = (Matrix *)(arg1)->transpose_times_self();
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Matrix,0);
    return vresult;
}


static VALUE
_wrap_Matrix_inverse(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = (Matrix *) 0 ;
    Matrix *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix, 1);
    result = (Matrix *)(arg1)->inverse();
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Matrix,0);
    return vresult;
}


static VALUE
_wrap_Matrix_transpose_times_vector(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = (Matrix *) 0 ;
    double *arg2 = (double *) 0 ;
    double *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_double, 1);
    result = (double *)(arg1)->transpose_times_vector(arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_double,0);
    return vresult;
}


static VALUE
_wrap_Matrix_times_vector(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = (Matrix *) 0 ;
    double *arg2 = (double *) 0 ;
    double *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_double, 1);
    result = (double *)(arg1)->times_vector(arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_double,0);
    return vresult;
}


static VALUE
_wrap_Matrix_print(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = (Matrix *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix, 1);
    (arg1)->print();
    
    return Qnil;
}


static VALUE
_wrap_Matrix5_size_set(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->size = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Matrix5_size_get(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    result = (int) ((arg1)->size);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Matrix5_d1_set(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    double *arg2 = (double *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_double, 1);
    if (arg1) (arg1)->d1 = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Matrix5_d1_get(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    double *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    result = (double *) ((arg1)->d1);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_double,0);
    return vresult;
}


static VALUE
_wrap_Matrix5_d2_set(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    double *arg2 = (double *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_double, 1);
    if (arg1) (arg1)->d2 = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Matrix5_d2_get(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    double *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    result = (double *) ((arg1)->d2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_double,0);
    return vresult;
}


static VALUE
_wrap_Matrix5_d3_set(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    double *arg2 = (double *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_double, 1);
    if (arg1) (arg1)->d3 = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Matrix5_d3_get(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    double *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    result = (double *) ((arg1)->d3);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_double,0);
    return vresult;
}


static VALUE
_wrap_Matrix5_d4_set(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    double *arg2 = (double *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_double, 1);
    if (arg1) (arg1)->d4 = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Matrix5_d4_get(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    double *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    result = (double *) ((arg1)->d4);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_double,0);
    return vresult;
}


static VALUE
_wrap_Matrix5_d5_set(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    double *arg2 = (double *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_double, 1);
    if (arg1) (arg1)->d5 = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Matrix5_d5_get(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    double *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    result = (double *) ((arg1)->d5);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_double,0);
    return vresult;
}


static VALUE
_wrap_Matrix5_factored_set(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    bool arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    arg2 = RTEST(argv[0]);
    if (arg1) (arg1)->factored = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Matrix5_factored_get(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    result = (bool) ((arg1)->factored);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_new_Matrix5__SWIG_0(int argc, VALUE *argv, VALUE self) {
    Matrix *arg1 = 0 ;
    Matrix5 *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_Matrix, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (Matrix5 *)new Matrix5((Matrix const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_Matrix5__SWIG_1(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = 0 ;
    Matrix5 *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_Matrix5, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (Matrix5 *)new Matrix5((Matrix5 const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Matrix5_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Matrix5_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Matrix5);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Matrix5__SWIG_2(int argc, VALUE *argv, VALUE self) {
    int arg1 ;
    Matrix5 *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    arg1 = NUM2INT(argv[0]);
    result = (Matrix5 *)new Matrix5(arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_Matrix5(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Matrix, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_Matrix5__SWIG_0(nargs, args, self);
        }
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Matrix5, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_Matrix5__SWIG_1(nargs, args, self);
        }
    }
    if (argc == 1) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_Matrix5__SWIG_2(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_Matrix5'");
    return Qnil;
}


static void
free_Matrix5(Matrix5 *arg1) {
    delete arg1;
}
static VALUE
_wrap_Matrix5_LUsolve(int argc, VALUE *argv, VALUE self) {
    Matrix5 *arg1 = (Matrix5 *) 0 ;
    double *arg2 = (double *) 0 ;
    double *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Matrix5, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_double, 1);
    result = (double *)(arg1)->LUsolve(arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_double,0);
    return vresult;
}


static VALUE
_wrap_add_filename_extension(int argc, VALUE *argv, VALUE self) {
    char *arg1 ;
    char *arg2 ;
    char *arg3 ;
    int arg4 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    arg1 = StringValuePtr(argv[0]);
    arg2 = StringValuePtr(argv[1]);
    arg3 = StringValuePtr(argv[2]);
    arg4 = NUM2INT(argv[3]);
    result = (int)add_filename_extension(arg1,arg2,arg3,arg4);
    
    vresult = INT2NUM(result);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Cell_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Cell_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Cell);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Cell(int argc, VALUE *argv, VALUE self) {
    Cell *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (Cell *)new Cell();
    DATA_PTR(self) = result;
    return self;
}


static void
free_Cell(Cell *arg1) {
    delete arg1;
}
static VALUE
_wrap_VertexCell_num_edges_set(int argc, VALUE *argv, VALUE self) {
    VertexCell *arg1 = (VertexCell *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_VertexCell, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->num_edges = arg2;
    
    return Qnil;
}


static VALUE
_wrap_VertexCell_num_edges_get(int argc, VALUE *argv, VALUE self) {
    VertexCell *arg1 = (VertexCell *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_VertexCell, 1);
    result = (int) ((arg1)->num_edges);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_VertexCell_max_edges_set(int argc, VALUE *argv, VALUE self) {
    VertexCell *arg1 = (VertexCell *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_VertexCell, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->max_edges = arg2;
    
    return Qnil;
}


static VALUE
_wrap_VertexCell_max_edges_get(int argc, VALUE *argv, VALUE self) {
    VertexCell *arg1 = (VertexCell *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_VertexCell, 1);
    result = (int) ((arg1)->max_edges);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_VertexCell_edges_set(int argc, VALUE *argv, VALUE self) {
    VertexCell *arg1 = (VertexCell *) 0 ;
    void **arg2 = (void **) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_VertexCell, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_p_void, 1);
    if (arg1) (arg1)->edges = arg2;
    
    return Qnil;
}


static VALUE
_wrap_VertexCell_edges_get(int argc, VALUE *argv, VALUE self) {
    VertexCell *arg1 = (VertexCell *) 0 ;
    void **result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_VertexCell, 1);
    result = (void **) ((arg1)->edges);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_p_void,0);
    return vresult;
}


static VALUE
_wrap_new_VertexCell__SWIG_0(int argc, VALUE *argv, VALUE self) {
    VertexCell *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (VertexCell *)new VertexCell();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_VertexCell_allocate(VALUE self) {
#else
    static VALUE
    _wrap_VertexCell_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_VertexCell);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_VertexCell__SWIG_1(int argc, VALUE *argv, VALUE self) {
    VertexCell *arg1 = 0 ;
    VertexCell *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_VertexCell, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (VertexCell *)new VertexCell((VertexCell const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_VertexCell(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_VertexCell__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_VertexCell, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_VertexCell__SWIG_1(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_VertexCell'");
    return Qnil;
}


static void
free_VertexCell(VertexCell *arg1) {
    delete arg1;
}
static VALUE
_wrap_VertexCell_add_edge(int argc, VALUE *argv, VALUE self) {
    VertexCell *arg1 = (VertexCell *) 0 ;
    void *arg2 = (void *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_VertexCell, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, 0, 1);
    result = (bool)(arg1)->add_edge(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_VertexCell_delete_edge(int argc, VALUE *argv, VALUE self) {
    VertexCell *arg1 = (VertexCell *) 0 ;
    void *arg2 = (void *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_VertexCell, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, 0, 1);
    result = (bool)(arg1)->delete_edge(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_EdgeCell_vertexs_set(int argc, VALUE *argv, VALUE self) {
    EdgeCell *arg1 = (EdgeCell *) 0 ;
    void **arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EdgeCell, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_p_void, 1);
    {
        int ii;
        void * *b = (void * *) arg1->vertexs;
        for (ii = 0; ii < 2; ii++) b[ii] = *((void * *) arg2 + ii);
    }
    return Qnil;
}


static VALUE
_wrap_EdgeCell_vertexs_get(int argc, VALUE *argv, VALUE self) {
    EdgeCell *arg1 = (EdgeCell *) 0 ;
    void **result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EdgeCell, 1);
    result = (void **)(void **) ((arg1)->vertexs);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_p_void,0);
    return vresult;
}


static VALUE
_wrap_EdgeCell_faces_set(int argc, VALUE *argv, VALUE self) {
    EdgeCell *arg1 = (EdgeCell *) 0 ;
    void **arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EdgeCell, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_p_void, 1);
    {
        int ii;
        void * *b = (void * *) arg1->faces;
        for (ii = 0; ii < 2; ii++) b[ii] = *((void * *) arg2 + ii);
    }
    return Qnil;
}


static VALUE
_wrap_EdgeCell_faces_get(int argc, VALUE *argv, VALUE self) {
    EdgeCell *arg1 = (EdgeCell *) 0 ;
    void **result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EdgeCell, 1);
    result = (void **)(void **) ((arg1)->faces);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_p_void,0);
    return vresult;
}


static VALUE
_wrap_new_EdgeCell__SWIG_0(int argc, VALUE *argv, VALUE self) {
    EdgeCell *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (EdgeCell *)new EdgeCell();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_EdgeCell_allocate(VALUE self) {
#else
    static VALUE
    _wrap_EdgeCell_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_EdgeCell);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_EdgeCell__SWIG_1(int argc, VALUE *argv, VALUE self) {
    EdgeCell *arg1 = 0 ;
    EdgeCell *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_EdgeCell, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (EdgeCell *)new EdgeCell((EdgeCell const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_EdgeCell(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_EdgeCell__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_EdgeCell, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_EdgeCell__SWIG_1(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_EdgeCell'");
    return Qnil;
}


static void
free_EdgeCell(EdgeCell *arg1) {
    delete arg1;
}
static VALUE
_wrap_EdgeCell_add_face(int argc, VALUE *argv, VALUE self) {
    EdgeCell *arg1 = (EdgeCell *) 0 ;
    void *arg2 = (void *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EdgeCell, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, 0, 1);
    result = (bool)(arg1)->add_face(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_EdgeCell_delete_face(int argc, VALUE *argv, VALUE self) {
    EdgeCell *arg1 = (EdgeCell *) 0 ;
    void *arg2 = (void *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EdgeCell, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, 0, 1);
    result = (bool)(arg1)->delete_face(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_FaceCell_num_edges_set(int argc, VALUE *argv, VALUE self) {
    FaceCell *arg1 = (FaceCell *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FaceCell, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->num_edges = arg2;
    
    return Qnil;
}


static VALUE
_wrap_FaceCell_num_edges_get(int argc, VALUE *argv, VALUE self) {
    FaceCell *arg1 = (FaceCell *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FaceCell, 1);
    result = (int) ((arg1)->num_edges);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_FaceCell_max_edges_set(int argc, VALUE *argv, VALUE self) {
    FaceCell *arg1 = (FaceCell *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FaceCell, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->max_edges = arg2;
    
    return Qnil;
}


static VALUE
_wrap_FaceCell_max_edges_get(int argc, VALUE *argv, VALUE self) {
    FaceCell *arg1 = (FaceCell *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FaceCell, 1);
    result = (int) ((arg1)->max_edges);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_FaceCell_edges_set(int argc, VALUE *argv, VALUE self) {
    FaceCell *arg1 = (FaceCell *) 0 ;
    void **arg2 = (void **) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FaceCell, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_p_void, 1);
    if (arg1) (arg1)->edges = arg2;
    
    return Qnil;
}


static VALUE
_wrap_FaceCell_edges_get(int argc, VALUE *argv, VALUE self) {
    FaceCell *arg1 = (FaceCell *) 0 ;
    void **result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FaceCell, 1);
    result = (void **) ((arg1)->edges);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_p_void,0);
    return vresult;
}


static VALUE
_wrap_new_FaceCell__SWIG_0(int argc, VALUE *argv, VALUE self) {
    FaceCell *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (FaceCell *)new FaceCell();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_FaceCell_allocate(VALUE self) {
#else
    static VALUE
    _wrap_FaceCell_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FaceCell);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_FaceCell__SWIG_1(int argc, VALUE *argv, VALUE self) {
    FaceCell *arg1 = 0 ;
    FaceCell *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_FaceCell, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (FaceCell *)new FaceCell((FaceCell const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_FaceCell(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_FaceCell__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_FaceCell, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_FaceCell__SWIG_1(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_FaceCell'");
    return Qnil;
}


static void
free_FaceCell(FaceCell *arg1) {
    delete arg1;
}
static VALUE
_wrap_FaceCell_add_edge(int argc, VALUE *argv, VALUE self) {
    FaceCell *arg1 = (FaceCell *) 0 ;
    void *arg2 = (void *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FaceCell, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, 0, 1);
    result = (bool)(arg1)->add_edge(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_FaceCell_delete_edge(int argc, VALUE *argv, VALUE self) {
    FaceCell *arg1 = (FaceCell *) 0 ;
    void *arg2 = (void *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FaceCell, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, 0, 1);
    result = (bool)(arg1)->delete_edge(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_FaceCell_has_vertex(int argc, VALUE *argv, VALUE self) {
    FaceCell *arg1 = (FaceCell *) 0 ;
    void *arg2 = (void *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_FaceCell, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, 0, 1);
    result = (bool)((FaceCell const *)arg1)->has_vertex(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BoundaryVertex_cp_set(int argc, VALUE *argv, VALUE self) {
    BoundaryVertex *arg1 = (BoundaryVertex *) 0 ;
    ControlPoint arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryVertex, 1);
    {
        ControlPoint * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_ControlPoint, 1);
        if (ptr) arg2 = *ptr;
    }
    if (arg1) (arg1)->cp = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryVertex_cp_get(int argc, VALUE *argv, VALUE self) {
    BoundaryVertex *arg1 = (BoundaryVertex *) 0 ;
    ControlPoint result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryVertex, 1);
    result =  ((arg1)->cp);
    
    {
        ControlPoint * resultptr;
        resultptr = new ControlPoint((ControlPoint &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_ControlPoint, 1);
    }
    return vresult;
}


static VALUE
_wrap_BoundaryVertex_fixed_set(int argc, VALUE *argv, VALUE self) {
    BoundaryVertex *arg1 = (BoundaryVertex *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryVertex, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->fixed = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryVertex_fixed_get(int argc, VALUE *argv, VALUE self) {
    BoundaryVertex *arg1 = (BoundaryVertex *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryVertex, 1);
    result = (int) ((arg1)->fixed);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BoundaryVertex_bezier_vertex_set(int argc, VALUE *argv, VALUE self) {
    BoundaryVertex *arg1 = (BoundaryVertex *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    if (arg1) (arg1)->bezier_vertex = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryVertex_bezier_vertex_get(int argc, VALUE *argv, VALUE self) {
    BoundaryVertex *arg1 = (BoundaryVertex *) 0 ;
    BezierVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryVertex, 1);
    result = (BezierVertex *) ((arg1)->bezier_vertex);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierVertex,0);
    return vresult;
}


static VALUE
_wrap_new_BoundaryVertex__SWIG_0(int argc, VALUE *argv, VALUE self) {
    BoundaryVertex *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (BoundaryVertex *)new BoundaryVertex();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_BoundaryVertex_allocate(VALUE self) {
#else
    static VALUE
    _wrap_BoundaryVertex_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_BoundaryVertex);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_BoundaryVertex__SWIG_1(int argc, VALUE *argv, VALUE self) {
    BoundaryVertex *arg1 = 0 ;
    BoundaryVertex *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BoundaryVertex, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (BoundaryVertex *)new BoundaryVertex((BoundaryVertex const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_BoundaryVertex(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_BoundaryVertex__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_BoundaryVertex__SWIG_1(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_BoundaryVertex'");
    return Qnil;
}


static void
free_BoundaryVertex(BoundaryVertex *arg1) {
    delete arg1;
}
static VALUE
_wrap_BoundaryVertex_set_fixed(int argc, VALUE *argv, VALUE self) {
    BoundaryVertex *arg1 = (BoundaryVertex *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryVertex, 1);
    arg2 = NUM2INT(argv[0]);
    (arg1)->set_fixed(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryVertex_set_cp(int argc, VALUE *argv, VALUE self) {
    BoundaryVertex *arg1 = (BoundaryVertex *) 0 ;
    Point2D *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->set_cp((Point2D const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryVertex_print(int argc, VALUE *argv, VALUE self) {
    BoundaryVertex *arg1 = (BoundaryVertex *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryVertex, 1);
    ((BoundaryVertex const *)arg1)->print();
    
    return Qnil;
}


static VALUE
_wrap_BoundaryVertex_get_cp(int argc, VALUE *argv, VALUE self) {
    BoundaryVertex *arg1 = (BoundaryVertex *) 0 ;
    Point2D *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryVertex, 1);
    {
        Point2D &_result_ref = ((BoundaryVertex const *)arg1)->get_cp();
        result = (Point2D *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Point2D,0);
    return vresult;
}


static VALUE
_wrap_BoundaryVertex_get_edge(int argc, VALUE *argv, VALUE self) {
    BoundaryVertex *arg1 = (BoundaryVertex *) 0 ;
    int arg2 ;
    BoundaryEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryVertex, 1);
    arg2 = NUM2INT(argv[0]);
    result = (BoundaryEdge *)((BoundaryVertex const *)arg1)->get_edge(arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryEdge,0);
    return vresult;
}


static VALUE
_wrap_BoundaryEdge_spline_set(int argc, VALUE *argv, VALUE self) {
    BoundaryEdge *arg1 = (BoundaryEdge *) 0 ;
    QBSpline *arg2 = (QBSpline *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_QBSpline, 1);
    if (arg1) (arg1)->spline = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryEdge_spline_get(int argc, VALUE *argv, VALUE self) {
    BoundaryEdge *arg1 = (BoundaryEdge *) 0 ;
    QBSpline *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryEdge, 1);
    result = (QBSpline *) ((arg1)->spline);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_QBSpline,0);
    return vresult;
}


static VALUE
_wrap_BoundaryEdge_fixed_set(int argc, VALUE *argv, VALUE self) {
    BoundaryEdge *arg1 = (BoundaryEdge *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryEdge, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->fixed = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryEdge_fixed_get(int argc, VALUE *argv, VALUE self) {
    BoundaryEdge *arg1 = (BoundaryEdge *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryEdge, 1);
    result = (int) ((arg1)->fixed);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BoundaryEdge_color_set(int argc, VALUE *argv, VALUE self) {
    BoundaryEdge *arg1 = (BoundaryEdge *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryEdge, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->color = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryEdge_color_get(int argc, VALUE *argv, VALUE self) {
    BoundaryEdge *arg1 = (BoundaryEdge *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryEdge, 1);
    result = (int) ((arg1)->color);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_new_BoundaryEdge__SWIG_0(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    BoundaryEdge *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    result = (BoundaryEdge *)new BoundaryEdge(arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_BoundaryEdge__SWIG_1(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    int arg2 ;
    int arg3 ;
    BoundaryEdge *result;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = NUM2INT(argv[1]);
    arg3 = NUM2INT(argv[2]);
    result = (BoundaryEdge *)new BoundaryEdge(arg1,arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_BoundaryEdge_allocate(VALUE self) {
#else
    static VALUE
    _wrap_BoundaryEdge_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_BoundaryEdge);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_BoundaryEdge__SWIG_2(int argc, VALUE *argv, VALUE self) {
    BoundaryEdge *arg1 = 0 ;
    BoundaryEdge *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BoundaryEdge, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (BoundaryEdge *)new BoundaryEdge((BoundaryEdge const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_BoundaryEdge(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[3];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_QBSpline, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_BoundaryEdge__SWIG_0(nargs, args, self);
        }
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BoundaryEdge, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_BoundaryEdge__SWIG_2(nargs, args, self);
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_QBSpline, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_new_BoundaryEdge__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_BoundaryEdge'");
    return Qnil;
}


static void
free_BoundaryEdge(BoundaryEdge *arg1) {
    delete arg1;
}
static VALUE
_wrap_BoundaryEdge_set_fixed(int argc, VALUE *argv, VALUE self) {
    BoundaryEdge *arg1 = (BoundaryEdge *) 0 ;
    int arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryEdge, 1);
    arg2 = NUM2INT(argv[0]);
    result = (int)(arg1)->set_fixed(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BoundaryEdge_set_color(int argc, VALUE *argv, VALUE self) {
    BoundaryEdge *arg1 = (BoundaryEdge *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryEdge, 1);
    arg2 = NUM2INT(argv[0]);
    (arg1)->set_color(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryEdge_set_restlength(int argc, VALUE *argv, VALUE self) {
    BoundaryEdge *arg1 = (BoundaryEdge *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryEdge, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    (arg1)->set_restlength(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryEdge_print(int argc, VALUE *argv, VALUE self) {
    BoundaryEdge *arg1 = (BoundaryEdge *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryEdge, 1);
    ((BoundaryEdge const *)arg1)->print();
    
    return Qnil;
}


static VALUE
_wrap_BoundaryEdge_get_vertex(int argc, VALUE *argv, VALUE self) {
    BoundaryEdge *arg1 = (BoundaryEdge *) 0 ;
    int arg2 ;
    BoundaryVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryEdge, 1);
    arg2 = NUM2INT(argv[0]);
    result = (BoundaryVertex *)((BoundaryEdge const *)arg1)->get_vertex(arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryVertex,0);
    return vresult;
}


static VALUE
_wrap_BoundaryEdge_get_face(int argc, VALUE *argv, VALUE self) {
    BoundaryEdge *arg1 = (BoundaryEdge *) 0 ;
    int arg2 ;
    BoundaryFace *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryEdge, 1);
    arg2 = NUM2INT(argv[0]);
    result = (BoundaryFace *)((BoundaryEdge const *)arg1)->get_face(arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryFace,0);
    return vresult;
}


static VALUE
_wrap_BoundaryFace_min_angle_set(int argc, VALUE *argv, VALUE self) {
    BoundaryFace *arg1 = (BoundaryFace *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryFace, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->min_angle = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryFace_min_angle_get(int argc, VALUE *argv, VALUE self) {
    BoundaryFace *arg1 = (BoundaryFace *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryFace, 1);
    result = (double) ((arg1)->min_angle);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_BoundaryFace_color_set(int argc, VALUE *argv, VALUE self) {
    BoundaryFace *arg1 = (BoundaryFace *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryFace, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->color = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryFace_color_get(int argc, VALUE *argv, VALUE self) {
    BoundaryFace *arg1 = (BoundaryFace *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryFace, 1);
    result = (int) ((arg1)->color);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_new_BoundaryFace__SWIG_0(int argc, VALUE *argv, VALUE self) {
    BoundaryFace *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (BoundaryFace *)new BoundaryFace();
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_BoundaryFace__SWIG_1(int argc, VALUE *argv, VALUE self) {
    double arg1 ;
    int arg2 ;
    BoundaryFace *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    arg1 = (double) NUM2DBL(argv[0]);
    arg2 = NUM2INT(argv[1]);
    result = (BoundaryFace *)new BoundaryFace(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_BoundaryFace_allocate(VALUE self) {
#else
    static VALUE
    _wrap_BoundaryFace_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_BoundaryFace);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_BoundaryFace__SWIG_2(int argc, VALUE *argv, VALUE self) {
    BoundaryFace *arg1 = 0 ;
    BoundaryFace *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BoundaryFace, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (BoundaryFace *)new BoundaryFace((BoundaryFace const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_BoundaryFace(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[2];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_BoundaryFace__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BoundaryFace, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_BoundaryFace__SWIG_2(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FLOAT) || (TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_BoundaryFace__SWIG_1(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_BoundaryFace'");
    return Qnil;
}


static void
free_BoundaryFace(BoundaryFace *arg1) {
    delete arg1;
}
static VALUE
_wrap_BoundaryFace_set_min_angle(int argc, VALUE *argv, VALUE self) {
    BoundaryFace *arg1 = (BoundaryFace *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryFace, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    (arg1)->set_min_angle(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryFace_set_color(int argc, VALUE *argv, VALUE self) {
    BoundaryFace *arg1 = (BoundaryFace *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryFace, 1);
    arg2 = NUM2INT(argv[0]);
    (arg1)->set_color(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryFace_print(int argc, VALUE *argv, VALUE self) {
    BoundaryFace *arg1 = (BoundaryFace *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryFace, 1);
    ((BoundaryFace const *)arg1)->print();
    
    return Qnil;
}


static VALUE
_wrap_BoundaryFace_get_edge(int argc, VALUE *argv, VALUE self) {
    BoundaryFace *arg1 = (BoundaryFace *) 0 ;
    int arg2 ;
    BoundaryEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryFace, 1);
    arg2 = NUM2INT(argv[0]);
    result = (BoundaryEdge *)((BoundaryFace const *)arg1)->get_edge(arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryEdge,0);
    return vresult;
}


static VALUE
_wrap_BezierVertex_cp_set(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    ControlPoint arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    {
        ControlPoint * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_ControlPoint, 1);
        if (ptr) arg2 = *ptr;
    }
    if (arg1) (arg1)->cp = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierVertex_cp_get(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    ControlPoint result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    result =  ((arg1)->cp);
    
    {
        ControlPoint * resultptr;
        resultptr = new ControlPoint((ControlPoint &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_ControlPoint, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierVertex_dp_set(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    DataPoint arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    {
        DataPoint * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_DataPoint, 1);
        if (ptr) arg2 = *ptr;
    }
    if (arg1) (arg1)->dp = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierVertex_dp_get(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    DataPoint result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    result =  ((arg1)->dp);
    
    {
        DataPoint * resultptr;
        resultptr = new DataPoint((DataPoint &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_DataPoint, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierVertex_bdry_edge_set(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    if (arg1) (arg1)->bdry_edge = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierVertex_bdry_edge_get(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    BoundaryEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    result = (BoundaryEdge *) ((arg1)->bdry_edge);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryEdge,0);
    return vresult;
}


static VALUE
_wrap_BezierVertex_bdry_vertex_set(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    if (arg1) (arg1)->bdry_vertex = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierVertex_bdry_vertex_get(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    BoundaryVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    result = (BoundaryVertex *) ((arg1)->bdry_vertex);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryVertex,0);
    return vresult;
}


static VALUE
_wrap_BezierVertex_u_set(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->u = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierVertex_u_get(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    result = (double) ((arg1)->u);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_BezierVertex_is_removeable_set(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    bool arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    arg2 = RTEST(argv[0]);
    if (arg1) (arg1)->is_removeable = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierVertex_is_removeable_get(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    result = (bool) ((arg1)->is_removeable);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_new_BezierVertex__SWIG_0(int argc, VALUE *argv, VALUE self) {
    BezierVertex *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (BezierVertex *)new BezierVertex();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_BezierVertex_allocate(VALUE self) {
#else
    static VALUE
    _wrap_BezierVertex_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_BezierVertex);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_BezierVertex__SWIG_1(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = 0 ;
    BezierVertex *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BezierVertex, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (BezierVertex *)new BezierVertex((BezierVertex const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_BezierVertex(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_BezierVertex__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_BezierVertex__SWIG_1(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_BezierVertex'");
    return Qnil;
}


static void
free_BezierVertex(BezierVertex *arg1) {
    delete arg1;
}
static VALUE
_wrap_BezierVertex_set_bdry__SWIG_0(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    double arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    arg3 = (double) NUM2DBL(argv[1]);
    (arg1)->set_bdry(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_BezierVertex_set_bdry__SWIG_1(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    (arg1)->set_bdry(arg2);
    
    return Qnil;
}


static VALUE _wrap_BezierVertex_set_bdry(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BezierVertex_set_bdry__SWIG_1(nargs, args, self);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FLOAT) || (TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierVertex_set_bdry__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BezierVertex_set_bdry'");
    return Qnil;
}


static VALUE
_wrap_BezierVertex_set_cp(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    Point2D *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->set_cp((Point2D const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_BezierVertex_set_dp(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    LinearData *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_LinearData, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->set_dp((LinearData const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_BezierVertex_get_cp(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    Point2D *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    {
        Point2D &_result_ref = ((BezierVertex const *)arg1)->get_cp();
        result = (Point2D *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Point2D,0);
    return vresult;
}


static VALUE
_wrap_BezierVertex_get_dp(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    LinearData *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    {
        LinearData &_result_ref = ((BezierVertex const *)arg1)->get_dp();
        result = (LinearData *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_LinearData,0);
    return vresult;
}


static VALUE
_wrap_BezierVertex_get_edge(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    int arg2 ;
    BezierEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    arg2 = NUM2INT(argv[0]);
    result = (BezierEdge *)((BezierVertex const *)arg1)->get_edge(arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierEdge,0);
    return vresult;
}


static VALUE
_wrap_BezierVertex_get_u__SWIG_0(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    BezierVertex *arg3 = (BezierVertex *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierVertex, 1);
    result = (double)((BezierVertex const *)arg1)->get_u(arg2,arg3);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_BezierVertex_get_u__SWIG_1(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    result = (double)((BezierVertex const *)arg1)->get_u(arg2);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE _wrap_BezierVertex_get_u(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BezierVertex_get_u__SWIG_1(nargs, args, self);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierVertex_get_u__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BezierVertex_get_u'");
    return Qnil;
}


static VALUE
_wrap_BezierVertex_print(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    ((BezierVertex const *)arg1)->print();
    
    return Qnil;
}


static VALUE
_wrap_BezierEdge_cp_set(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    ControlPoint *arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ControlPoint, 1);
    {
        int ii;
        ControlPoint *b = (ControlPoint *) arg1->cp;
        for (ii = 0; ii < 3; ii++) b[ii] = *((ControlPoint *) arg2 + ii);
    }
    return Qnil;
}


static VALUE
_wrap_BezierEdge_cp_get(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    ControlPoint *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    result = (ControlPoint *)(ControlPoint *) ((arg1)->cp);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_ControlPoint,0);
    return vresult;
}


static VALUE
_wrap_BezierEdge_dp_set(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    DataPoint *arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_DataPoint, 1);
    {
        int ii;
        DataPoint *b = (DataPoint *) arg1->dp;
        for (ii = 0; ii < 3; ii++) b[ii] = *((DataPoint *) arg2 + ii);
    }
    return Qnil;
}


static VALUE
_wrap_BezierEdge_dp_get(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    DataPoint *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    result = (DataPoint *)(DataPoint *) ((arg1)->dp);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_DataPoint,0);
    return vresult;
}


static VALUE
_wrap_BezierEdge_bdry_set(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    if (arg1) (arg1)->bdry = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierEdge_bdry_get(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    BoundaryEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    result = (BoundaryEdge *) ((arg1)->bdry);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryEdge,0);
    return vresult;
}


static VALUE
_wrap_BezierEdge_u0_set(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->u0 = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierEdge_u0_get(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    result = (double) ((arg1)->u0);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_BezierEdge_u1_set(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->u1 = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierEdge_u1_get(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    result = (double) ((arg1)->u1);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_new_BezierEdge__SWIG_0(int argc, VALUE *argv, VALUE self) {
    BezierEdge *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (BezierEdge *)new BezierEdge();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_BezierEdge_allocate(VALUE self) {
#else
    static VALUE
    _wrap_BezierEdge_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_BezierEdge);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_BezierEdge__SWIG_1(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = 0 ;
    BezierEdge *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BezierEdge, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (BezierEdge *)new BezierEdge((BezierEdge const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_BezierEdge(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_BezierEdge__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_BezierEdge__SWIG_1(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_BezierEdge'");
    return Qnil;
}


static void
free_BezierEdge(BezierEdge *arg1) {
    delete arg1;
}
static VALUE
_wrap_BezierEdge_set_bdry(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    double arg3 ;
    double arg4 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    arg3 = (double) NUM2DBL(argv[1]);
    arg4 = (double) NUM2DBL(argv[2]);
    (arg1)->set_bdry(arg2,arg3,arg4);
    
    return Qnil;
}


static VALUE
_wrap_BezierEdge_set_cp(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    Point2D *arg2 = 0 ;
    int arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg3 = NUM2INT(argv[1]);
    (arg1)->set_cp((Point2D const &)*arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_BezierEdge_set_dp(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    LinearData *arg2 = 0 ;
    int arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_LinearData, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg3 = NUM2INT(argv[1]);
    (arg1)->set_dp((LinearData const &)*arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_BezierEdge_get_cp(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    int arg2 ;
    Point2D *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    arg2 = NUM2INT(argv[0]);
    {
        Point2D &_result_ref = ((BezierEdge const *)arg1)->get_cp(arg2);
        result = (Point2D *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Point2D,0);
    return vresult;
}


static VALUE
_wrap_BezierEdge_get_dp(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    int arg2 ;
    LinearData *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    arg2 = NUM2INT(argv[0]);
    {
        LinearData &_result_ref = ((BezierEdge const *)arg1)->get_dp(arg2);
        result = (LinearData *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_LinearData,0);
    return vresult;
}


static VALUE
_wrap_BezierEdge_get_vertex(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    int arg2 ;
    BezierVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    arg2 = NUM2INT(argv[0]);
    result = (BezierVertex *)((BezierEdge const *)arg1)->get_vertex(arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierVertex,0);
    return vresult;
}


static VALUE
_wrap_BezierEdge_get_face(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    int arg2 ;
    BezierTriangle *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    arg2 = NUM2INT(argv[0]);
    result = (BezierTriangle *)((BezierEdge const *)arg1)->get_face(arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierTriangle,0);
    return vresult;
}


static VALUE
_wrap_BezierEdge_eval(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    double arg2 ;
    Point2D result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    result = ((BezierEdge const *)arg1)->eval(arg2);
    
    {
        Point2D * resultptr;
        resultptr = new Point2D((Point2D &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Point2D, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierEdge_dataeval(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    double arg2 ;
    LinearData result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    result = ((BezierEdge const *)arg1)->dataeval(arg2);
    
    {
        LinearData * resultptr;
        resultptr = new LinearData((LinearData &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_LinearData, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierEdge_evalIntermediate(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    double arg2 ;
    Point2D *arg3 = 0 ;
    Point2D *arg4 = 0 ;
    Point2D *arg5 = 0 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Point2D, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_Point2D, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_Point2D, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    ((BezierEdge const *)arg1)->evalIntermediate(arg2,*arg3,*arg4,*arg5);
    
    return Qnil;
}


static VALUE
_wrap_BezierEdge_dataevalIntermediate(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    double arg2 ;
    LinearData *arg3 = 0 ;
    LinearData *arg4 = 0 ;
    LinearData *arg5 = 0 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_LinearData, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_LinearData, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_LinearData, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    ((BezierEdge const *)arg1)->dataevalIntermediate(arg2,*arg3,*arg4,*arg5);
    
    return Qnil;
}


static VALUE
_wrap_BezierEdge_is_encroached(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    Point2D *arg2 = 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (bool)((BezierEdge const *)arg1)->is_encroached(*arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BezierEdge_left_of_curve(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    Point2D *arg2 = 0 ;
    int arg3 ;
    double *arg4 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg3 = NUM2INT(argv[1]);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_double, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)((BezierEdge const *)arg1)->left_of_curve(*arg2,arg3,*arg4);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BezierEdge_print(int argc, VALUE *argv, VALUE self) {
    BezierEdge *arg1 = (BezierEdge *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierEdge, 1);
    ((BezierEdge const *)arg1)->print();
    
    return Qnil;
}


static VALUE
newton_optimal_tolerance_get(VALUE self) {
    VALUE _val;
    
    _val = rb_float_new(newton_optimal_tolerance);    return _val;
}


static VALUE
newton_zero_tolerance_get(VALUE self) {
    VALUE _val;
    
    _val = rb_float_new(newton_zero_tolerance);    return _val;
}


static VALUE
newton_tolerance_get(VALUE self) {
    VALUE _val;
    
    _val = rb_float_new(newton_tolerance);    return _val;
}


static VALUE
newton_iterations_get(VALUE self) {
    VALUE _val;
    
    _val = UINT2NUM(newton_iterations);    return _val;
}


static VALUE
_wrap_CurvedTriangle_newton_find(int argc, VALUE *argv, VALUE self) {
    CurvedTriangle *arg1 = (CurvedTriangle *) 0 ;
    Point2D *arg2 = 0 ;
    double *arg3 = 0 ;
    double *arg4 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CurvedTriangle, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_double, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_double, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)((CurvedTriangle const *)arg1)->newton_find((Point2D const &)*arg2,*arg3,*arg4);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_CurvedTriangle_jacobian_matrix(int argc, VALUE *argv, VALUE self) {
    CurvedTriangle *arg1 = (CurvedTriangle *) 0 ;
    double arg2 ;
    double arg3 ;
    Point2D *arg4 = 0 ;
    Point2D *arg5 = 0 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CurvedTriangle, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_Point2D, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_Point2D, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    ((CurvedTriangle const *)arg1)->jacobian_matrix(arg2,arg3,*arg4,*arg5);
    
    return Qnil;
}


static VALUE
_wrap_CurvedTriangle_eval(int argc, VALUE *argv, VALUE self) {
    CurvedTriangle *arg1 = (CurvedTriangle *) 0 ;
    double arg2 ;
    double arg3 ;
    Point2D result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CurvedTriangle, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    result = ((CurvedTriangle const *)arg1)->eval(arg2,arg3);
    
    {
        Point2D * resultptr;
        resultptr = new Point2D((Point2D &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Point2D, 1);
    }
    return vresult;
}


static void
free_CurvedTriangle(CurvedTriangle *arg1) {
    delete arg1;
}
static VALUE
_wrap_BezierTriangle_cp_set(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    ControlPoint *arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ControlPoint, 1);
    {
        int ii;
        ControlPoint *b = (ControlPoint *) arg1->cp;
        for (ii = 0; ii < 6; ii++) b[ii] = *((ControlPoint *) arg2 + ii);
    }
    return Qnil;
}


static VALUE
_wrap_BezierTriangle_cp_get(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    ControlPoint *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    result = (ControlPoint *)(ControlPoint *) ((arg1)->cp);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_ControlPoint,0);
    return vresult;
}


static VALUE
_wrap_BezierTriangle_dp_set(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    DataPoint *arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_DataPoint, 1);
    {
        int ii;
        DataPoint *b = (DataPoint *) arg1->dp;
        for (ii = 0; ii < 6; ii++) b[ii] = *((DataPoint *) arg2 + ii);
    }
    return Qnil;
}


static VALUE
_wrap_BezierTriangle_dp_get(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    DataPoint *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    result = (DataPoint *)(DataPoint *) ((arg1)->dp);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_DataPoint,0);
    return vresult;
}


static VALUE
_wrap_BezierTriangle_bdry_face_set(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    if (arg1) (arg1)->bdry_face = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierTriangle_bdry_face_get(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    BoundaryFace *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    result = (BoundaryFace *) ((arg1)->bdry_face);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryFace,0);
    return vresult;
}


static VALUE
_wrap_new_BezierTriangle__SWIG_0(int argc, VALUE *argv, VALUE self) {
    BoundaryFace *arg1 = (BoundaryFace *) 0 ;
    BezierTriangle *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BoundaryFace, 1);
    result = (BezierTriangle *)new BezierTriangle(arg1);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_BezierTriangle_allocate(VALUE self) {
#else
    static VALUE
    _wrap_BezierTriangle_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_BezierTriangle);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_BezierTriangle__SWIG_1(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = 0 ;
    BezierTriangle *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (BezierTriangle *)new BezierTriangle((BezierTriangle const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_BezierTriangle(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BoundaryFace, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_BezierTriangle__SWIG_0(nargs, args, self);
        }
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_BezierTriangle__SWIG_1(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_BezierTriangle'");
    return Qnil;
}


static void
free_BezierTriangle(BezierTriangle *arg1) {
    delete arg1;
}
static VALUE
_wrap_BezierTriangle_set_cp(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    Point2D *arg2 = 0 ;
    int arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg3 = NUM2INT(argv[1]);
    (arg1)->set_cp((Point2D const &)*arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_BezierTriangle_set_dp(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    LinearData *arg2 = 0 ;
    int arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_LinearData, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg3 = NUM2INT(argv[1]);
    (arg1)->set_dp((LinearData const &)*arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_BezierTriangle_get_cp(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    int arg2 ;
    Point2D *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    arg2 = NUM2INT(argv[0]);
    {
        Point2D &_result_ref = ((BezierTriangle const *)arg1)->get_cp(arg2);
        result = (Point2D *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Point2D,0);
    return vresult;
}


static VALUE
_wrap_BezierTriangle_get_dp(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    int arg2 ;
    LinearData *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    arg2 = NUM2INT(argv[0]);
    {
        LinearData &_result_ref = ((BezierTriangle const *)arg1)->get_dp(arg2);
        result = (LinearData *) &_result_ref;
    }
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_LinearData,0);
    return vresult;
}


static VALUE
_wrap_BezierTriangle_get_edge(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    int arg2 ;
    BezierEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    arg2 = NUM2INT(argv[0]);
    result = (BezierEdge *)((BezierTriangle const *)arg1)->get_edge(arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierEdge,0);
    return vresult;
}


static VALUE
_wrap_BezierTriangle_eval(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    double arg2 ;
    double arg3 ;
    Point2D result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    result = ((BezierTriangle const *)arg1)->eval(arg2,arg3);
    
    {
        Point2D * resultptr;
        resultptr = new Point2D((Point2D &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Point2D, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierTriangle_dataeval(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    double arg2 ;
    double arg3 ;
    LinearData result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    result = ((BezierTriangle const *)arg1)->dataeval(arg2,arg3);
    
    {
        LinearData * resultptr;
        resultptr = new LinearData((LinearData &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_LinearData, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierTriangle_dataevalIntermediate(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    double arg2 ;
    double arg3 ;
    LinearData *arg4 = 0 ;
    LinearData *arg5 = 0 ;
    LinearData *arg6 = 0 ;
    LinearData *arg7 = 0 ;
    
    if ((argc < 6) || (argc > 6))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_LinearData, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_LinearData, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[4], (void **) &arg6, SWIGTYPE_p_LinearData, 1); if (arg6 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[5], (void **) &arg7, SWIGTYPE_p_LinearData, 1); if (arg7 == NULL) rb_raise(rb_eTypeError, "null reference");
    ((BezierTriangle const *)arg1)->dataevalIntermediate(arg2,arg3,*arg4,*arg5,*arg6,*arg7);
    
    return Qnil;
}


static VALUE
_wrap_BezierTriangle_evalIntermediate(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    double arg2 ;
    double arg3 ;
    Point2D *arg4 = 0 ;
    Point2D *arg5 = 0 ;
    Point2D *arg6 = 0 ;
    Point2D *arg7 = 0 ;
    
    if ((argc < 6) || (argc > 6))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_Point2D, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_Point2D, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[4], (void **) &arg6, SWIGTYPE_p_Point2D, 1); if (arg6 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[5], (void **) &arg7, SWIGTYPE_p_Point2D, 1); if (arg7 == NULL) rb_raise(rb_eTypeError, "null reference");
    ((BezierTriangle const *)arg1)->evalIntermediate(arg2,arg3,*arg4,*arg5,*arg6,*arg7);
    
    return Qnil;
}


static VALUE
_wrap_BezierTriangle_jacobian(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    double arg2 ;
    double arg3 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    result = (double)((BezierTriangle const *)arg1)->jacobian(arg2,arg3);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_BezierTriangle_jacobian_matrix(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    double arg2 ;
    double arg3 ;
    Point2D *arg4 = 0 ;
    Point2D *arg5 = 0 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_Point2D, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_Point2D, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    ((BezierTriangle const *)arg1)->jacobian_matrix(arg2,arg3,*arg4,*arg5);
    
    return Qnil;
}


static VALUE
_wrap_BezierTriangle_bound_jacobian(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    double *arg2 = 0 ;
    double *arg3 = 0 ;
    double *arg4 = 0 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_double, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_double, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_double, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    ((BezierTriangle const *)arg1)->bound_jacobian(*arg2,*arg3,*arg4);
    
    return Qnil;
}


static VALUE
_wrap_BezierTriangle_small_angle(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    result = (bool)((BezierTriangle const *)arg1)->small_angle();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BezierTriangle_is_inverted(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    result = (bool)((BezierTriangle const *)arg1)->is_inverted();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BezierTriangle_circumcenter(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    Point2D result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    result = ((BezierTriangle const *)arg1)->circumcenter();
    
    {
        Point2D * resultptr;
        resultptr = new Point2D((Point2D &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Point2D, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierTriangle_print(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    ((BezierTriangle const *)arg1)->print();
    
    return Qnil;
}


static VALUE
_wrap_BezierTriangle_print_mathematica(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = (BezierTriangle *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1);
    ((BezierTriangle const *)arg1)->print_mathematica();
    
    return Qnil;
}


static VALUE
_wrap_GhostTriangle_cp_set(int argc, VALUE *argv, VALUE self) {
    GhostTriangle *arg1 = (GhostTriangle *) 0 ;
    Point2D *arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GhostTriangle, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1);
    {
        int ii;
        Point2D *b = (Point2D *) arg1->cp;
        for (ii = 0; ii < 6; ii++) b[ii] = *((Point2D *) arg2 + ii);
    }
    return Qnil;
}


static VALUE
_wrap_GhostTriangle_cp_get(int argc, VALUE *argv, VALUE self) {
    GhostTriangle *arg1 = (GhostTriangle *) 0 ;
    Point2D *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GhostTriangle, 1);
    result = (Point2D *)(Point2D *) ((arg1)->cp);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Point2D,0);
    return vresult;
}


static VALUE
_wrap_GhostTriangle_dp_set(int argc, VALUE *argv, VALUE self) {
    GhostTriangle *arg1 = (GhostTriangle *) 0 ;
    LinearData *arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GhostTriangle, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_LinearData, 1);
    {
        int ii;
        LinearData *b = (LinearData *) arg1->dp;
        for (ii = 0; ii < 6; ii++) b[ii] = *((LinearData *) arg2 + ii);
    }
    return Qnil;
}


static VALUE
_wrap_GhostTriangle_dp_get(int argc, VALUE *argv, VALUE self) {
    GhostTriangle *arg1 = (GhostTriangle *) 0 ;
    LinearData *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GhostTriangle, 1);
    result = (LinearData *)(LinearData *) ((arg1)->dp);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_LinearData,0);
    return vresult;
}


static VALUE
_wrap_new_GhostTriangle__SWIG_0(int argc, VALUE *argv, VALUE self) {
    BezierTriangle *arg1 = 0 ;
    GhostTriangle *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BezierTriangle, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (GhostTriangle *)new GhostTriangle((BezierTriangle const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_GhostTriangle_allocate(VALUE self) {
#else
    static VALUE
    _wrap_GhostTriangle_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_GhostTriangle);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_GhostTriangle__SWIG_1(int argc, VALUE *argv, VALUE self) {
    GhostTriangle *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (GhostTriangle *)new GhostTriangle();
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_GhostTriangle(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_GhostTriangle__SWIG_1(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_GhostTriangle__SWIG_0(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_GhostTriangle'");
    return Qnil;
}


static void
free_GhostTriangle(GhostTriangle *arg1) {
    delete arg1;
}
static VALUE
_wrap_GhostTriangle_set_cp(int argc, VALUE *argv, VALUE self) {
    GhostTriangle *arg1 = (GhostTriangle *) 0 ;
    int arg2 ;
    Point2D arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GhostTriangle, 1);
    arg2 = NUM2INT(argv[0]);
    {
        Point2D * ptr;
        SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_Point2D, 1);
        if (ptr) arg3 = *ptr;
    }
    (arg1)->set_cp(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_GhostTriangle_get_cp(int argc, VALUE *argv, VALUE self) {
    GhostTriangle *arg1 = (GhostTriangle *) 0 ;
    int arg2 ;
    Point2D result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GhostTriangle, 1);
    arg2 = NUM2INT(argv[0]);
    result = ((GhostTriangle const *)arg1)->get_cp(arg2);
    
    {
        Point2D * resultptr;
        resultptr = new Point2D((Point2D &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Point2D, 1);
    }
    return vresult;
}


static VALUE
_wrap_GhostTriangle_jacobian_matrix(int argc, VALUE *argv, VALUE self) {
    GhostTriangle *arg1 = (GhostTriangle *) 0 ;
    double arg2 ;
    double arg3 ;
    Point2D *arg4 = 0 ;
    Point2D *arg5 = 0 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GhostTriangle, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_Point2D, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_Point2D, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    ((GhostTriangle const *)arg1)->jacobian_matrix(arg2,arg3,*arg4,*arg5);
    
    return Qnil;
}


static VALUE
_wrap_GhostTriangle_jacobian(int argc, VALUE *argv, VALUE self) {
    GhostTriangle *arg1 = (GhostTriangle *) 0 ;
    double arg2 ;
    double arg3 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GhostTriangle, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    result = (double)((GhostTriangle const *)arg1)->jacobian(arg2,arg3);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_GhostTriangle_dataeval(int argc, VALUE *argv, VALUE self) {
    GhostTriangle *arg1 = (GhostTriangle *) 0 ;
    double arg2 ;
    double arg3 ;
    LinearData result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GhostTriangle, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    result = ((GhostTriangle const *)arg1)->dataeval(arg2,arg3);
    
    {
        LinearData * resultptr;
        resultptr = new LinearData((LinearData &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_LinearData, 1);
    }
    return vresult;
}


static VALUE
_wrap_GhostTriangle_eval(int argc, VALUE *argv, VALUE self) {
    GhostTriangle *arg1 = (GhostTriangle *) 0 ;
    double arg2 ;
    double arg3 ;
    Point2D result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GhostTriangle, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    result = ((GhostTriangle const *)arg1)->eval(arg2,arg3);
    
    {
        Point2D * resultptr;
        resultptr = new Point2D((Point2D &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Point2D, 1);
    }
    return vresult;
}


static VALUE
_wrap_GhostTriangle_print(int argc, VALUE *argv, VALUE self) {
    GhostTriangle *arg1 = (GhostTriangle *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GhostTriangle, 1);
    ((GhostTriangle const *)arg1)->print();
    
    return Qnil;
}


static VALUE
_wrap_GhostTriangle_print_mathematica(int argc, VALUE *argv, VALUE self) {
    GhostTriangle *arg1 = (GhostTriangle *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_GhostTriangle, 1);
    ((GhostTriangle const *)arg1)->print_mathematica();
    
    return Qnil;
}


static VALUE
_wrap_BezierTuple_v_set(int argc, VALUE *argv, VALUE self) {
    CellTuple<BezierVertex,BezierEdge,BezierTriangle > *arg1 = (CellTuple<BezierVertex,BezierEdge,BezierTriangle > *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    if (arg1) (arg1)->v = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierTuple_v_get(int argc, VALUE *argv, VALUE self) {
    CellTuple<BezierVertex,BezierEdge,BezierTriangle > *arg1 = (CellTuple<BezierVertex,BezierEdge,BezierTriangle > *) 0 ;
    BezierVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t, 1);
    result = (BezierVertex *) ((arg1)->v);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierVertex,0);
    return vresult;
}


static VALUE
_wrap_BezierTuple_e_set(int argc, VALUE *argv, VALUE self) {
    CellTuple<BezierVertex,BezierEdge,BezierTriangle > *arg1 = (CellTuple<BezierVertex,BezierEdge,BezierTriangle > *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    if (arg1) (arg1)->e = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierTuple_e_get(int argc, VALUE *argv, VALUE self) {
    CellTuple<BezierVertex,BezierEdge,BezierTriangle > *arg1 = (CellTuple<BezierVertex,BezierEdge,BezierTriangle > *) 0 ;
    BezierEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t, 1);
    result = (BezierEdge *) ((arg1)->e);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierEdge,0);
    return vresult;
}


static VALUE
_wrap_BezierTuple_f_set(int argc, VALUE *argv, VALUE self) {
    CellTuple<BezierVertex,BezierEdge,BezierTriangle > *arg1 = (CellTuple<BezierVertex,BezierEdge,BezierTriangle > *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    if (arg1) (arg1)->f = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierTuple_f_get(int argc, VALUE *argv, VALUE self) {
    CellTuple<BezierVertex,BezierEdge,BezierTriangle > *arg1 = (CellTuple<BezierVertex,BezierEdge,BezierTriangle > *) 0 ;
    BezierTriangle *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t, 1);
    result = (BezierTriangle *) ((arg1)->f);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierTriangle,0);
    return vresult;
}


static VALUE
_wrap_new_BezierTuple__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellTuple<BezierVertex,BezierEdge,BezierTriangle > *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (CellTuple<BezierVertex,BezierEdge,BezierTriangle > *)new CellTuple<BezierVertex,BezierEdge,BezierTriangle >();
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_BezierTuple__SWIG_1(int argc, VALUE *argv, VALUE self) {
    BezierVertex *arg1 = (BezierVertex *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    BezierTriangle *arg3 = (BezierTriangle *) 0 ;
    CellTuple<BezierVertex,BezierEdge,BezierTriangle > *result;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_BezierTriangle, 1);
    result = (CellTuple<BezierVertex,BezierEdge,BezierTriangle > *)new CellTuple<BezierVertex,BezierEdge,BezierTriangle >(arg1,arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_BezierTuple_allocate(VALUE self) {
#else
    static VALUE
    _wrap_BezierTuple_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_BezierTuple__SWIG_2(int argc, VALUE *argv, VALUE self) {
    CellTuple<BezierVertex,BezierEdge,BezierTriangle > *arg1 = 0 ;
    CellTuple<BezierVertex,BezierEdge,BezierTriangle > *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (CellTuple<BezierVertex,BezierEdge,BezierTriangle > *)new CellTuple<BezierVertex,BezierEdge,BezierTriangle >((CellTuple<BezierVertex,BezierEdge,BezierTriangle > const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_BezierTuple(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[3];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_BezierTuple__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_BezierTuple__SWIG_2(nargs, args, self);
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_new_BezierTuple__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_BezierTuple'");
    return Qnil;
}


static VALUE
_wrap_BezierTuple_print(int argc, VALUE *argv, VALUE self) {
    CellTuple<BezierVertex,BezierEdge,BezierTriangle > *arg1 = (CellTuple<BezierVertex,BezierEdge,BezierTriangle > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t, 1);
    (arg1)->print();
    
    return Qnil;
}


static VALUE
_wrap_BezierTuple_print_detail(int argc, VALUE *argv, VALUE self) {
    CellTuple<BezierVertex,BezierEdge,BezierTriangle > *arg1 = (CellTuple<BezierVertex,BezierEdge,BezierTriangle > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t, 1);
    (arg1)->print_detail();
    
    return Qnil;
}


static void
free_CellTuplelBezierVertexcBezierEdgecBezierTriangle_g___(CellTuple<BezierVertex,BezierEdge,BezierTriangle > *arg1) {
    delete arg1;
}
static VALUE
_wrap_BoundaryTuple_v_set(int argc, VALUE *argv, VALUE self) {
    CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *arg1 = (CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    if (arg1) (arg1)->v = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryTuple_v_get(int argc, VALUE *argv, VALUE self) {
    CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *arg1 = (CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *) 0 ;
    BoundaryVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t, 1);
    result = (BoundaryVertex *) ((arg1)->v);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryVertex,0);
    return vresult;
}


static VALUE
_wrap_BoundaryTuple_e_set(int argc, VALUE *argv, VALUE self) {
    CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *arg1 = (CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    if (arg1) (arg1)->e = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryTuple_e_get(int argc, VALUE *argv, VALUE self) {
    CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *arg1 = (CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *) 0 ;
    BoundaryEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t, 1);
    result = (BoundaryEdge *) ((arg1)->e);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryEdge,0);
    return vresult;
}


static VALUE
_wrap_BoundaryTuple_f_set(int argc, VALUE *argv, VALUE self) {
    CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *arg1 = (CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    if (arg1) (arg1)->f = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryTuple_f_get(int argc, VALUE *argv, VALUE self) {
    CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *arg1 = (CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *) 0 ;
    BoundaryFace *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t, 1);
    result = (BoundaryFace *) ((arg1)->f);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryFace,0);
    return vresult;
}


static VALUE
_wrap_new_BoundaryTuple__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *)new CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace >();
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_BoundaryTuple__SWIG_1(int argc, VALUE *argv, VALUE self) {
    BoundaryVertex *arg1 = (BoundaryVertex *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    BoundaryFace *arg3 = (BoundaryFace *) 0 ;
    CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *result;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_BoundaryFace, 1);
    result = (CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *)new CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace >(arg1,arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_BoundaryTuple_allocate(VALUE self) {
#else
    static VALUE
    _wrap_BoundaryTuple_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_BoundaryTuple__SWIG_2(int argc, VALUE *argv, VALUE self) {
    CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *arg1 = 0 ;
    CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *)new CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace >((CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_BoundaryTuple(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[3];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_BoundaryTuple__SWIG_0(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_BoundaryTuple__SWIG_2(nargs, args, self);
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BoundaryFace, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_new_BoundaryTuple__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_BoundaryTuple'");
    return Qnil;
}


static VALUE
_wrap_BoundaryTuple_print(int argc, VALUE *argv, VALUE self) {
    CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *arg1 = (CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t, 1);
    (arg1)->print();
    
    return Qnil;
}


static VALUE
_wrap_BoundaryTuple_print_detail(int argc, VALUE *argv, VALUE self) {
    CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *arg1 = (CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t, 1);
    (arg1)->print_detail();
    
    return Qnil;
}


static void
free_CellTuplelBoundaryVertexcBoundaryEdgecBoundaryFace_g___(CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *arg1) {
    delete arg1;
}
static VALUE
_wrap_QBSpline_b_set(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    vector<ControlPoint > arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    {
        vector<ControlPoint > * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_vectorTlistTPoint2D_t__iterator_t, 1);
        if (ptr) arg2 = *ptr;
    }
    if (arg1) (arg1)->b = arg2;
    
    return Qnil;
}


static VALUE
_wrap_QBSpline_b_get(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    vector<ControlPoint > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    result =  ((arg1)->b);
    
    {
        vector<ControlPoint > * resultptr;
        resultptr = new vector<ControlPoint >((vector<ControlPoint > &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_vectorTlistTPoint2D_t__iterator_t, 1);
    }
    return vresult;
}


static VALUE
_wrap_QBSpline_k_set(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    vector<double > arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    {
        vector<double > * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_vectorTdouble_t, 1);
        if (ptr) arg2 = *ptr;
    }
    if (arg1) (arg1)->k = arg2;
    
    return Qnil;
}


static VALUE
_wrap_QBSpline_k_get(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    vector<double > result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    result =  ((arg1)->k);
    
    {
        vector<double > * resultptr;
        resultptr = new vector<double >((vector<double > &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_vectorTdouble_t, 1);
    }
    return vresult;
}


static VALUE
_wrap_QBSpline_vertexs_set(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    vector<BezierVertex * > *arg2 = (vector<BezierVertex * > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTBezierVertex_p_t, 1);
    if (arg1) (arg1)->vertexs = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_QBSpline_vertexs_get(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    vector<BezierVertex * > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    result = (vector<BezierVertex * > *)& ((arg1)->vertexs);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTBezierVertex_p_t,0);
    return vresult;
}


static VALUE
_wrap_QBSpline_closed_set(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    bool arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = RTEST(argv[0]);
    if (arg1) (arg1)->closed = arg2;
    
    return Qnil;
}


static VALUE
_wrap_QBSpline_closed_get(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    result = (bool) ((arg1)->closed);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_QBSpline_restlength_set(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->restlength = arg2;
    
    return Qnil;
}


static VALUE
_wrap_QBSpline_restlength_get(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    result = (double) ((arg1)->restlength);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_QBSpline_bdry_mesh_set(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    BoundaryMesh *arg2 = (BoundaryMesh *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryMesh, 1);
    if (arg1) (arg1)->bdry_mesh = arg2;
    
    return Qnil;
}


static VALUE
_wrap_QBSpline_bdry_mesh_get(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    BoundaryMesh *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    result = (BoundaryMesh *) ((arg1)->bdry_mesh);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryMesh,0);
    return vresult;
}


static VALUE
_wrap_new_QBSpline__SWIG_0(int argc, VALUE *argv, VALUE self) {
    vector<ControlPoint > *arg1 = 0 ;
    BoundaryMesh *arg2 = (BoundaryMesh *) 0 ;
    QBSpline *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_vectorTlistTPoint2D_t__iterator_t, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_BoundaryMesh, 1);
    result = (QBSpline *)new QBSpline((vector<ControlPoint > const &)*arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_QBSpline__SWIG_1(int argc, VALUE *argv, VALUE self) {
    vector<ControlPoint > *arg1 = 0 ;
    vector<double > *arg2 = 0 ;
    BoundaryMesh *arg3 = (BoundaryMesh *) 0 ;
    QBSpline *result;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_vectorTlistTPoint2D_t__iterator_t, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_vectorTdouble_t, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_BoundaryMesh, 1);
    result = (QBSpline *)new QBSpline((vector<ControlPoint > const &)*arg1,(vector<double > const &)*arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_QBSpline__SWIG_2(int argc, VALUE *argv, VALUE self) {
    vector<ControlPoint > *arg1 = 0 ;
    vector<double > *arg2 = 0 ;
    BoundaryMesh *arg3 = (BoundaryMesh *) 0 ;
    double arg4 ;
    QBSpline *result;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_vectorTlistTPoint2D_t__iterator_t, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_vectorTdouble_t, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg3, SWIGTYPE_p_BoundaryMesh, 1);
    arg4 = (double) NUM2DBL(argv[3]);
    result = (QBSpline *)new QBSpline((vector<ControlPoint > const &)*arg1,(vector<double > const &)*arg2,arg3,arg4);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_QBSpline_allocate(VALUE self) {
#else
    static VALUE
    _wrap_QBSpline_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_QBSpline);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_QBSpline__SWIG_3(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = 0 ;
    QBSpline *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_QBSpline, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (QBSpline *)new QBSpline((QBSpline const &)*arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_QBSpline(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 4); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_QBSpline, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_QBSpline__SWIG_3(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_vectorTlistTPoint2D_t__iterator_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryMesh, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_QBSpline__SWIG_0(nargs, args, self);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_vectorTlistTPoint2D_t__iterator_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_vectorTdouble_t, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BoundaryMesh, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_new_QBSpline__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_vectorTlistTPoint2D_t__iterator_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_vectorTdouble_t, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BoundaryMesh, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    {
                        _v = ((TYPE(argv[3]) == T_FLOAT) || (TYPE(argv[3]) == T_FIXNUM) || (TYPE(argv[3]) == T_BIGNUM)) ? 1 : 0;
                    }
                    if (_v) {
                        return _wrap_new_QBSpline__SWIG_2(nargs, args, self);
                    }
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_QBSpline'");
    return Qnil;
}


static void
free_QBSpline(QBSpline *arg1) {
    delete arg1;
}
static VALUE
_wrap_QBSpline_set_bezier_vertex(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    double arg2 ;
    BezierVertex *arg3 = (BezierVertex *) 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierVertex, 1);
    (arg1)->set_bezier_vertex(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_QBSpline_move(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    Point2D *arg2 = (Point2D *) 0 ;
    Point2D *arg3 = (Point2D *) 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Point2D, 1);
    (arg1)->move(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_QBSpline_add_knot(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    double arg2 ;
    ControlPoint *arg3 = 0 ;
    ControlPoint *arg4 = 0 ;
    ControlPoint *arg5 = 0 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_ControlPoint, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_ControlPoint, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_ControlPoint, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->add_knot(arg2,*arg3,*arg4,*arg5);
    
    return Qnil;
}


static VALUE
_wrap_QBSpline_remove_knot(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    double arg2 ;
    ControlPoint *arg3 = 0 ;
    double *arg4 = 0 ;
    double *arg5 = 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_ControlPoint, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_double, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_double, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (bool)(arg1)->remove_knot(arg2,*arg3,*arg4,*arg5);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_QBSpline_get_num_segments(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    result = (int)((QBSpline const *)arg1)->get_num_segments();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_QBSpline_get_num_deboor(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    result = (int)((QBSpline const *)arg1)->get_num_deboor();
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_QBSpline_get_deboor(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    int arg2 ;
    ControlPoint result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = NUM2INT(argv[0]);
    result = ((QBSpline const *)arg1)->get_deboor(arg2);
    
    {
        ControlPoint * resultptr;
        resultptr = new ControlPoint((ControlPoint &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_ControlPoint, 1);
    }
    return vresult;
}


static VALUE
_wrap_QBSpline_getip(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    double arg2 ;
    int *arg3 = (int *) 0 ;
    double *arg4 = (double *) 0 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_int, 1);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_double, 1);
    ((QBSpline const *)arg1)->getip(arg2,arg3,arg4);
    
    return Qnil;
}


static VALUE
_wrap_QBSpline_evaluate(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    double arg2 ;
    Point2D result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    result = ((QBSpline const *)arg1)->evaluate(arg2);
    
    {
        Point2D * resultptr;
        resultptr = new Point2D((Point2D &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Point2D, 1);
    }
    return vresult;
}


static VALUE
_wrap_QBSpline_evaluate_segment(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    int arg2 ;
    double arg3 ;
    Point2D result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    result = ((QBSpline const *)arg1)->evaluate_segment(arg2,arg3);
    
    {
        Point2D * resultptr;
        resultptr = new Point2D((Point2D &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Point2D, 1);
    }
    return vresult;
}


static VALUE
_wrap_QBSpline_get_closest_knot(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    double arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    result = (int)((QBSpline const *)arg1)->get_closest_knot(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_QBSpline_get_closest_bezier(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    double arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    result = (int)((QBSpline const *)arg1)->get_closest_bezier(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_QBSpline_get_edge_cps(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    double arg2 ;
    double arg3 ;
    ControlPoint *arg4 = 0 ;
    ControlPoint *arg5 = 0 ;
    ControlPoint *arg6 = 0 ;
    int *arg7 = 0 ;
    int *arg8 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 7) || (argc > 7))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_ControlPoint, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_ControlPoint, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[4], (void **) &arg6, SWIGTYPE_p_ControlPoint, 1); if (arg6 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[5], (void **) &arg7, SWIGTYPE_p_int, 1); if (arg7 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[6], (void **) &arg8, SWIGTYPE_p_int, 1); if (arg8 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)((QBSpline const *)arg1)->get_edge_cps(arg2,arg3,*arg4,*arg5,*arg6,*arg7,*arg8);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_QBSpline_get_segment_center(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    double arg2 ;
    double arg3 ;
    ControlPoint result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = (double) NUM2DBL(argv[1]);
    result = ((QBSpline const *)arg1)->get_segment_center(arg2,arg3);
    
    {
        ControlPoint * resultptr;
        resultptr = new ControlPoint((ControlPoint &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_ControlPoint, 1);
    }
    return vresult;
}


static VALUE
_wrap_QBSpline_douglas_peucker(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    double arg2 ;
    hash_set<BezierVertex *,CellHasher<BezierVertex >,CellEqual<BezierVertex > > *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_hash_setTBezierVertex_p_CellHasherTBezierVertex_t_CellEqualTBezierVertex_t_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    ((QBSpline const *)arg1)->douglas_peucker(arg2,*arg3);
    
    return Qnil;
}


static VALUE
_wrap_QBSpline_bbox(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    double *arg2 = (double *) 0 ;
    double *arg3 = (double *) 0 ;
    double *arg4 = (double *) 0 ;
    double *arg5 = (double *) 0 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_double, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_double, 1);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_double, 1);
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_double, 1);
    ((QBSpline const *)arg1)->bbox(arg2,arg3,arg4,arg5);
    
    return Qnil;
}


static VALUE
_wrap_QBSpline_print(int argc, VALUE *argv, VALUE self) {
    QBSpline *arg1 = (QBSpline *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_QBSpline, 1);
    ((QBSpline const *)arg1)->print();
    
    return Qnil;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_BezierComplex_allocate(VALUE self) {
#else
    static VALUE
    _wrap_BezierComplex_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_BezierComplex(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *)new CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple >();
    DATA_PTR(self) = result;
    return self;
}


static void
free_CellComplexlBezierVertexcBezierEdgecBezierTrianglecBezierTuple_g___(CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1) {
    delete arg1;
}
static VALUE
_wrap_BezierComplex_import_mesh(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->import_mesh((CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_add_cp(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    Point2D *arg2 = 0 ;
    ControlPoint result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (arg1)->add_cp((Point2D const &)*arg2);
    
    {
        ControlPoint * resultptr;
        resultptr = new ControlPoint((ControlPoint &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_ControlPoint, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierComplex_rem_cp(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    ControlPoint arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    {
        ControlPoint * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_ControlPoint, 1);
        if (ptr) arg2 = *ptr;
    }
    (arg1)->rem_cp(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_add_dp(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    ControlPoint arg2 ;
    LinearData *arg3 = 0 ;
    DataPoint result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    {
        ControlPoint * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_ControlPoint, 1);
        if (ptr) arg2 = *ptr;
    }
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_LinearData, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (arg1)->add_dp(arg2,(LinearData const &)*arg3);
    
    {
        DataPoint * resultptr;
        resultptr = new DataPoint((DataPoint &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_DataPoint, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierComplex_rem_dp(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    ControlPoint arg2 ;
    DataPoint arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    {
        ControlPoint * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_ControlPoint, 1);
        if (ptr) arg2 = *ptr;
    }
    {
        DataPoint * ptr;
        SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_DataPoint, 1);
        if (ptr) arg3 = *ptr;
    }
    (arg1)->rem_dp(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_add_vertex(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    (arg1)->add_vertex(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_add_edge(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    BezierVertex *arg3 = (BezierVertex *) 0 ;
    BezierVertex *arg4 = (BezierVertex *) 0 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_BezierVertex, 1);
    (arg1)->add_edge(arg2,arg3,arg4);
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_add_face(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    BezierEdge **arg3 = (BezierEdge **) 0 ;
    int arg4 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_p_BezierEdge, 1);
    arg4 = NUM2INT(argv[2]);
    (arg1)->add_face(arg2,arg3,arg4);
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_delete_vertex(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    (arg1)->delete_vertex(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_delete_edge(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    (arg1)->delete_edge(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_delete_face(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    (arg1)->delete_face(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_is_member__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    result = (bool)(arg1)->is_member(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BezierComplex_is_member__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    result = (bool)(arg1)->is_member(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BezierComplex_is_member__SWIG_2(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    result = (bool)(arg1)->is_member(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE _wrap_BezierComplex_is_member(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[3];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BezierComplex_is_member__SWIG_0(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BezierComplex_is_member__SWIG_1(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BezierComplex_is_member__SWIG_2(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BezierComplex_is_member'");
    return Qnil;
}


static VALUE
_wrap_BezierComplex_lower__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    vector<BezierVertex * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_vectorTBezierVertex_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->lower(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BezierComplex_lower__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    list<BezierVertex * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_listTBezierVertex_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->lower(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BezierComplex_lower__SWIG_2(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    vector<BezierEdge * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_vectorTBezierEdge_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->lower(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BezierComplex_lower__SWIG_3(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    list<BezierEdge * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_listTBezierEdge_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->lower(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE _wrap_BezierComplex_lower(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_vectorTBezierVertex_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_lower__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_listTBezierVertex_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_lower__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_vectorTBezierEdge_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_lower__SWIG_2(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_listTBezierEdge_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_lower__SWIG_3(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BezierComplex_lower'");
    return Qnil;
}


static VALUE
_wrap_BezierComplex_upper__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    vector<BezierTriangle * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_vectorTBezierTriangle_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->upper(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BezierComplex_upper__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    list<BezierTriangle * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_listTBezierTriangle_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->upper(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BezierComplex_upper__SWIG_2(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    vector<BezierEdge * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_vectorTBezierEdge_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->upper(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BezierComplex_upper__SWIG_3(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    list<BezierEdge * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_listTBezierEdge_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->upper(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE _wrap_BezierComplex_upper(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_vectorTBezierTriangle_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_upper__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_listTBezierTriangle_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_upper__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_vectorTBezierEdge_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_upper__SWIG_2(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_listTBezierEdge_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_upper__SWIG_3(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BezierComplex_upper'");
    return Qnil;
}


static VALUE
_wrap_BezierComplex_get_opposite_vertex(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    BezierVertex *arg3 = (BezierVertex *) 0 ;
    BezierVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierVertex, 1);
    result = (BezierVertex *)(arg1)->get_opposite_vertex(arg2,arg3);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierVertex,0);
    return vresult;
}


static VALUE
_wrap_BezierComplex_get_opposite_face(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    BezierTriangle *arg3 = (BezierTriangle *) 0 ;
    BezierTriangle *result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierTriangle, 1);
    result = (BezierTriangle *)(arg1)->get_opposite_face(arg2,arg3);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierTriangle,0);
    return vresult;
}


static VALUE
_wrap_BezierComplex_enqueue_faces(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    deque<BezierTriangle * > *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_dequeTBezierTriangle_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->enqueue_faces(arg2,*arg3);
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_enqueue_edges(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    deque<BezierEdge * > *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_dequeTBezierEdge_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->enqueue_edges(arg2,*arg3);
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_find_common_edge__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    BezierVertex *arg3 = (BezierVertex *) 0 ;
    BezierEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierVertex, 1);
    result = (BezierEdge *)(arg1)->find_common_edge(arg2,arg3);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierEdge,0);
    return vresult;
}


static VALUE
_wrap_BezierComplex_find_common_edge__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    BezierTriangle *arg3 = (BezierTriangle *) 0 ;
    BezierEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierTriangle, 1);
    result = (BezierEdge *)(arg1)->find_common_edge(arg2,arg3);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierEdge,0);
    return vresult;
}


static VALUE _wrap_BezierComplex_find_common_edge(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_find_common_edge__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_find_common_edge__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BezierComplex_find_common_edge'");
    return Qnil;
}


static VALUE
_wrap_BezierComplex_find_adjacent_faces__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    list<BezierTriangle * > *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_listTBezierTriangle_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->find_adjacent_faces(arg2,*arg3);
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_find_adjacent_edges__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    list<BezierEdge * > *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_listTBezierEdge_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->find_adjacent_edges(arg2,*arg3);
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_find_adjacent_faces__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    deque<BezierTriangle * > *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_dequeTBezierTriangle_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->find_adjacent_faces(arg2,*arg3);
    
    return Qnil;
}


static VALUE _wrap_BezierComplex_find_adjacent_faces(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_listTBezierTriangle_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_find_adjacent_faces__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_dequeTBezierTriangle_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_find_adjacent_faces__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BezierComplex_find_adjacent_faces'");
    return Qnil;
}


static VALUE
_wrap_BezierComplex_find_adjacent_edges__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    deque<BezierEdge * > *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_dequeTBezierEdge_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->find_adjacent_edges(arg2,*arg3);
    
    return Qnil;
}


static VALUE _wrap_BezierComplex_find_adjacent_edges(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_listTBezierEdge_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_find_adjacent_edges__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_dequeTBezierEdge_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_find_adjacent_edges__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BezierComplex_find_adjacent_edges'");
    return Qnil;
}


static VALUE
_wrap_BezierComplex_Switch(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    int arg2 ;
    BezierTuple *arg3 = 0 ;
    BezierTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    arg2 = NUM2INT(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierTuple, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (arg1)->Switch(arg2,(BezierTuple const &)*arg3);
    
    {
        BezierTuple * resultptr;
        resultptr = new BezierTuple((BezierTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierComplex_get_tuple__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    result = (arg1)->get_tuple();
    
    {
        BezierTuple * resultptr;
        resultptr = new BezierTuple((BezierTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierComplex_get_tuple__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    BezierTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    result = (arg1)->get_tuple(arg2);
    
    {
        BezierTuple * resultptr;
        resultptr = new BezierTuple((BezierTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierComplex_get_tuple__SWIG_2(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    BezierTriangle *arg3 = (BezierTriangle *) 0 ;
    BezierTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierTriangle, 1);
    result = (arg1)->get_tuple(arg2,arg3);
    
    {
        BezierTuple * resultptr;
        resultptr = new BezierTuple((BezierTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierComplex_get_tuple__SWIG_3(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    BezierTriangle *arg3 = (BezierTriangle *) 0 ;
    BezierTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierTriangle, 1);
    result = (arg1)->get_tuple(arg2,arg3);
    
    {
        BezierTuple * resultptr;
        resultptr = new BezierTuple((BezierTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierComplex_get_tuple__SWIG_4(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    BezierTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    result = (arg1)->get_tuple(arg2);
    
    {
        BezierTuple * resultptr;
        resultptr = new BezierTuple((BezierTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierComplex_get_tuple__SWIG_5(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    BezierTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    result = (arg1)->get_tuple(arg2);
    
    {
        BezierTuple * resultptr;
        resultptr = new BezierTuple((BezierTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierComplex_get_tuple__SWIG_6(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    BezierEdge *arg3 = (BezierEdge *) 0 ;
    BezierTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierEdge, 1);
    result = (arg1)->get_tuple(arg2,arg3);
    
    {
        BezierTuple * resultptr;
        resultptr = new BezierTuple((BezierTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierTuple, 1);
    }
    return vresult;
}


static VALUE _wrap_BezierComplex_get_tuple(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_BezierComplex_get_tuple__SWIG_0(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BezierComplex_get_tuple__SWIG_1(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BezierComplex_get_tuple__SWIG_4(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BezierComplex_get_tuple__SWIG_5(nargs, args, self);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_get_tuple__SWIG_2(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_get_tuple__SWIG_3(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierComplex_get_tuple__SWIG_6(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BezierComplex_get_tuple'");
    return Qnil;
}


static VALUE
_wrap_BezierComplex_is_ccw_tuple(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierTuple arg2 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    {
        BezierTuple * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BezierTuple, 1);
        if (ptr) arg2 = *ptr;
    }
    result = (bool)(arg1)->is_ccw_tuple(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BezierComplex_is_inverted(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    result = (bool)(arg1)->is_inverted(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BezierComplex_print(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    (arg1)->print();
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_print_statistics(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    (arg1)->print_statistics();
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_num_vertexs_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->num_vertexs = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_num_vertexs_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    result = (int) ((arg1)->num_vertexs);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BezierComplex_num_edges_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->num_edges = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_num_edges_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    result = (int) ((arg1)->num_edges);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BezierComplex_num_faces_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->num_faces = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_num_faces_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    result = (int) ((arg1)->num_faces);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BezierComplex_control_points_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    list<Point2D > *arg2 = (list<Point2D > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_listTPoint2D_t, 1);
    if (arg1) (arg1)->control_points = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_control_points_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    list<Point2D > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    result = (list<Point2D > *)& ((arg1)->control_points);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_listTPoint2D_t,0);
    return vresult;
}


static VALUE
_wrap_BezierComplex_data_points_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    list<LinearData > *arg2 = (list<LinearData > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_listTLinearData_t, 1);
    if (arg1) (arg1)->data_points = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_data_points_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    list<LinearData > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    result = (list<LinearData > *)& ((arg1)->data_points);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_listTLinearData_t,0);
    return vresult;
}


static VALUE
_wrap_BezierComplex_data_hash_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Data_Hash_T arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    {
        CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Data_Hash_T * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_hash_mapTlistTPoint2D_t__iterator_listTLinearData_t__iterator_ControlPointHasher_ControlPointEqual_t, 1);
        if (ptr) arg2 = *ptr;
    }
    if (arg1) (arg1)->data_hash = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_data_hash_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Data_Hash_T result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    result =  ((arg1)->data_hash);
    
    {
        CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Data_Hash_T * resultptr;
        resultptr = new CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Data_Hash_T((CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Data_Hash_T &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_hash_mapTlistTPoint2D_t__iterator_listTLinearData_t__iterator_ControlPointHasher_ControlPointEqual_t, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierComplex_vertexs_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Vertex_Hash_T *arg2 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Vertex_Hash_T *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_hash_setTBezierVertex_p_CellHasherTBezierVertex_t_CellEqualTBezierVertex_t_t, 1);
    if (arg1) (arg1)->vertexs = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_vertexs_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Vertex_Hash_T *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    result = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Vertex_Hash_T *)& ((arg1)->vertexs);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_hash_setTBezierVertex_p_CellHasherTBezierVertex_t_CellEqualTBezierVertex_t_t,0);
    return vresult;
}


static VALUE
_wrap_BezierComplex_edges_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Edge_Hash_T *arg2 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Edge_Hash_T *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_hash_setTBezierEdge_p_CellHasherTBezierEdge_t_CellEqualTBezierEdge_t_t, 1);
    if (arg1) (arg1)->edges = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_edges_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Edge_Hash_T *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    result = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Edge_Hash_T *)& ((arg1)->edges);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_hash_setTBezierEdge_p_CellHasherTBezierEdge_t_CellEqualTBezierEdge_t_t,0);
    return vresult;
}


static VALUE
_wrap_BezierComplex_faces_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Face_Hash_T *arg2 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Face_Hash_T *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_hash_setTBezierTriangle_p_CellHasherTBezierTriangle_t_CellEqualTBezierTriangle_t_t, 1);
    if (arg1) (arg1)->faces = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierComplex_faces_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *arg1 = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *) 0 ;
    CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Face_Hash_T *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 1);
    result = (CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Face_Hash_T *)& ((arg1)->faces);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_hash_setTBezierTriangle_p_CellHasherTBezierTriangle_t_CellEqualTBezierTriangle_t_t,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_BoundaryComplex_allocate(VALUE self) {
#else
    static VALUE
    _wrap_BoundaryComplex_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_BoundaryComplex(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *)new CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple >();
    DATA_PTR(self) = result;
    return self;
}


static void
free_CellComplexlBoundaryVertexcBoundaryEdgecBoundaryFacecBoundaryTuple_g___(CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1) {
    delete arg1;
}
static VALUE
_wrap_BoundaryComplex_import_mesh(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg2 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->import_mesh((CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > const &)*arg2);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_add_cp(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    Point2D *arg2 = 0 ;
    ControlPoint result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (arg1)->add_cp((Point2D const &)*arg2);
    
    {
        ControlPoint * resultptr;
        resultptr = new ControlPoint((ControlPoint &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_ControlPoint, 1);
    }
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_rem_cp(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    ControlPoint arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    {
        ControlPoint * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_ControlPoint, 1);
        if (ptr) arg2 = *ptr;
    }
    (arg1)->rem_cp(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_add_dp(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    ControlPoint arg2 ;
    LinearData *arg3 = 0 ;
    DataPoint result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    {
        ControlPoint * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_ControlPoint, 1);
        if (ptr) arg2 = *ptr;
    }
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_LinearData, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (arg1)->add_dp(arg2,(LinearData const &)*arg3);
    
    {
        DataPoint * resultptr;
        resultptr = new DataPoint((DataPoint &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_DataPoint, 1);
    }
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_rem_dp(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    ControlPoint arg2 ;
    DataPoint arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    {
        ControlPoint * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_ControlPoint, 1);
        if (ptr) arg2 = *ptr;
    }
    {
        DataPoint * ptr;
        SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_DataPoint, 1);
        if (ptr) arg3 = *ptr;
    }
    (arg1)->rem_dp(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_add_vertex(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    (arg1)->add_vertex(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_add_edge(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    BoundaryVertex *arg3 = (BoundaryVertex *) 0 ;
    BoundaryVertex *arg4 = (BoundaryVertex *) 0 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_BoundaryVertex, 1);
    (arg1)->add_edge(arg2,arg3,arg4);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_add_face(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    BoundaryEdge **arg3 = (BoundaryEdge **) 0 ;
    int arg4 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_p_BoundaryEdge, 1);
    arg4 = NUM2INT(argv[2]);
    (arg1)->add_face(arg2,arg3,arg4);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_delete_vertex(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    (arg1)->delete_vertex(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_delete_edge(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    (arg1)->delete_edge(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_delete_face(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    (arg1)->delete_face(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_is_member__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    result = (bool)(arg1)->is_member(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_is_member__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    result = (bool)(arg1)->is_member(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_is_member__SWIG_2(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    result = (bool)(arg1)->is_member(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE _wrap_BoundaryComplex_is_member(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[3];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BoundaryComplex_is_member__SWIG_0(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BoundaryComplex_is_member__SWIG_1(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryFace, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BoundaryComplex_is_member__SWIG_2(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BoundaryComplex_is_member'");
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_lower__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    vector<BoundaryVertex * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_vectorTBoundaryVertex_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->lower(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_lower__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    list<BoundaryVertex * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_listTBoundaryVertex_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->lower(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_lower__SWIG_2(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    vector<BoundaryEdge * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_vectorTBoundaryEdge_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->lower(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_lower__SWIG_3(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    list<BoundaryEdge * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_listTBoundaryEdge_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->lower(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE _wrap_BoundaryComplex_lower(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_vectorTBoundaryVertex_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_lower__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_listTBoundaryVertex_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_lower__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryFace, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_vectorTBoundaryEdge_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_lower__SWIG_2(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryFace, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_listTBoundaryEdge_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_lower__SWIG_3(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BoundaryComplex_lower'");
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_upper__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    vector<BoundaryFace * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_vectorTBoundaryFace_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->upper(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_upper__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    list<BoundaryFace * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_listTBoundaryFace_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->upper(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_upper__SWIG_2(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    vector<BoundaryEdge * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_vectorTBoundaryEdge_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->upper(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_upper__SWIG_3(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    list<BoundaryEdge * > *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_listTBoundaryEdge_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->upper(arg2,*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE _wrap_BoundaryComplex_upper(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_vectorTBoundaryFace_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_upper__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_listTBoundaryFace_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_upper__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_vectorTBoundaryEdge_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_upper__SWIG_2(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_listTBoundaryEdge_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_upper__SWIG_3(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BoundaryComplex_upper'");
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_get_opposite_vertex(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    BoundaryVertex *arg3 = (BoundaryVertex *) 0 ;
    BoundaryVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BoundaryVertex, 1);
    result = (BoundaryVertex *)(arg1)->get_opposite_vertex(arg2,arg3);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryVertex,0);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_get_opposite_face(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    BoundaryFace *arg3 = (BoundaryFace *) 0 ;
    BoundaryFace *result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BoundaryFace, 1);
    result = (BoundaryFace *)(arg1)->get_opposite_face(arg2,arg3);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryFace,0);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_enqueue_faces(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    deque<BoundaryFace * > *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_dequeTBoundaryFace_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->enqueue_faces(arg2,*arg3);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_enqueue_edges(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    deque<BoundaryEdge * > *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_dequeTBoundaryEdge_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->enqueue_edges(arg2,*arg3);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_find_common_edge__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    BoundaryVertex *arg3 = (BoundaryVertex *) 0 ;
    BoundaryEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BoundaryVertex, 1);
    result = (BoundaryEdge *)(arg1)->find_common_edge(arg2,arg3);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryEdge,0);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_find_common_edge__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    BoundaryFace *arg3 = (BoundaryFace *) 0 ;
    BoundaryEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BoundaryFace, 1);
    result = (BoundaryEdge *)(arg1)->find_common_edge(arg2,arg3);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryEdge,0);
    return vresult;
}


static VALUE _wrap_BoundaryComplex_find_common_edge(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_find_common_edge__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryFace, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BoundaryFace, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_find_common_edge__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BoundaryComplex_find_common_edge'");
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_find_adjacent_faces__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    list<BoundaryFace * > *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_listTBoundaryFace_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->find_adjacent_faces(arg2,*arg3);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_find_adjacent_edges__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    list<BoundaryEdge * > *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_listTBoundaryEdge_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->find_adjacent_edges(arg2,*arg3);
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_find_adjacent_faces__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    deque<BoundaryFace * > *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_dequeTBoundaryFace_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->find_adjacent_faces(arg2,*arg3);
    
    return Qnil;
}


static VALUE _wrap_BoundaryComplex_find_adjacent_faces(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryFace, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_listTBoundaryFace_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_find_adjacent_faces__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryFace, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_dequeTBoundaryFace_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_find_adjacent_faces__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BoundaryComplex_find_adjacent_faces'");
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_find_adjacent_edges__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    deque<BoundaryEdge * > *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_dequeTBoundaryEdge_p_t, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->find_adjacent_edges(arg2,*arg3);
    
    return Qnil;
}


static VALUE _wrap_BoundaryComplex_find_adjacent_edges(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_listTBoundaryEdge_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_find_adjacent_edges__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_dequeTBoundaryEdge_p_t, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_find_adjacent_edges__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BoundaryComplex_find_adjacent_edges'");
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_Switch(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    int arg2 ;
    BoundaryTuple *arg3 = 0 ;
    BoundaryTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    arg2 = NUM2INT(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BoundaryTuple, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (arg1)->Switch(arg2,(BoundaryTuple const &)*arg3);
    
    {
        BoundaryTuple * resultptr;
        resultptr = new BoundaryTuple((BoundaryTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BoundaryTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_get_tuple__SWIG_0(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    result = (arg1)->get_tuple();
    
    {
        BoundaryTuple * resultptr;
        resultptr = new BoundaryTuple((BoundaryTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BoundaryTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_get_tuple__SWIG_1(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    BoundaryTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    result = (arg1)->get_tuple(arg2);
    
    {
        BoundaryTuple * resultptr;
        resultptr = new BoundaryTuple((BoundaryTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BoundaryTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_get_tuple__SWIG_2(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    BoundaryFace *arg3 = (BoundaryFace *) 0 ;
    BoundaryTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BoundaryFace, 1);
    result = (arg1)->get_tuple(arg2,arg3);
    
    {
        BoundaryTuple * resultptr;
        resultptr = new BoundaryTuple((BoundaryTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BoundaryTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_get_tuple__SWIG_3(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    BoundaryFace *arg3 = (BoundaryFace *) 0 ;
    BoundaryTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BoundaryFace, 1);
    result = (arg1)->get_tuple(arg2,arg3);
    
    {
        BoundaryTuple * resultptr;
        resultptr = new BoundaryTuple((BoundaryTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BoundaryTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_get_tuple__SWIG_4(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    BoundaryTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    result = (arg1)->get_tuple(arg2);
    
    {
        BoundaryTuple * resultptr;
        resultptr = new BoundaryTuple((BoundaryTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BoundaryTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_get_tuple__SWIG_5(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    BoundaryTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    result = (arg1)->get_tuple(arg2);
    
    {
        BoundaryTuple * resultptr;
        resultptr = new BoundaryTuple((BoundaryTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BoundaryTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_get_tuple__SWIG_6(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    BoundaryEdge *arg3 = (BoundaryEdge *) 0 ;
    BoundaryTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BoundaryEdge, 1);
    result = (arg1)->get_tuple(arg2,arg3);
    
    {
        BoundaryTuple * resultptr;
        resultptr = new BoundaryTuple((BoundaryTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BoundaryTuple, 1);
    }
    return vresult;
}


static VALUE _wrap_BoundaryComplex_get_tuple(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_BoundaryComplex_get_tuple__SWIG_0(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryFace, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BoundaryComplex_get_tuple__SWIG_1(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BoundaryComplex_get_tuple__SWIG_4(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BoundaryComplex_get_tuple__SWIG_5(nargs, args, self);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BoundaryFace, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_get_tuple__SWIG_2(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BoundaryFace, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_get_tuple__SWIG_3(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BoundaryEdge, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BoundaryComplex_get_tuple__SWIG_6(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BoundaryComplex_get_tuple'");
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_is_ccw_tuple(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryTuple arg2 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    {
        BoundaryTuple * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_BoundaryTuple, 1);
        if (ptr) arg2 = *ptr;
    }
    result = (bool)(arg1)->is_ccw_tuple(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_is_inverted(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    result = (bool)(arg1)->is_inverted(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_print(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    (arg1)->print();
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_print_statistics(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    (arg1)->print_statistics();
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_num_vertexs_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->num_vertexs = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_num_vertexs_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    result = (int) ((arg1)->num_vertexs);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_num_edges_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->num_edges = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_num_edges_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    result = (int) ((arg1)->num_edges);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_num_faces_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->num_faces = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_num_faces_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    result = (int) ((arg1)->num_faces);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_control_points_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    list<Point2D > *arg2 = (list<Point2D > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_listTPoint2D_t, 1);
    if (arg1) (arg1)->control_points = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_control_points_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    list<Point2D > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    result = (list<Point2D > *)& ((arg1)->control_points);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_listTPoint2D_t,0);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_data_points_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    list<LinearData > *arg2 = (list<LinearData > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_listTLinearData_t, 1);
    if (arg1) (arg1)->data_points = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_data_points_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    list<LinearData > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    result = (list<LinearData > *)& ((arg1)->data_points);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_listTLinearData_t,0);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_data_hash_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Data_Hash_T arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    {
        CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Data_Hash_T * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_hash_mapTlistTPoint2D_t__iterator_listTLinearData_t__iterator_ControlPointHasher_ControlPointEqual_t, 1);
        if (ptr) arg2 = *ptr;
    }
    if (arg1) (arg1)->data_hash = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_data_hash_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Data_Hash_T result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    result =  ((arg1)->data_hash);
    
    {
        CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Data_Hash_T * resultptr;
        resultptr = new CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Data_Hash_T((CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Data_Hash_T &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_hash_mapTlistTPoint2D_t__iterator_listTLinearData_t__iterator_ControlPointHasher_ControlPointEqual_t, 1);
    }
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_vertexs_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Vertex_Hash_T *arg2 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Vertex_Hash_T *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_hash_setTBoundaryVertex_p_CellHasherTBoundaryVertex_t_CellEqualTBoundaryVertex_t_t, 1);
    if (arg1) (arg1)->vertexs = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_vertexs_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Vertex_Hash_T *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    result = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Vertex_Hash_T *)& ((arg1)->vertexs);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_hash_setTBoundaryVertex_p_CellHasherTBoundaryVertex_t_CellEqualTBoundaryVertex_t_t,0);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_edges_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Edge_Hash_T *arg2 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Edge_Hash_T *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_hash_setTBoundaryEdge_p_CellHasherTBoundaryEdge_t_CellEqualTBoundaryEdge_t_t, 1);
    if (arg1) (arg1)->edges = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_edges_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Edge_Hash_T *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    result = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Edge_Hash_T *)& ((arg1)->edges);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_hash_setTBoundaryEdge_p_CellHasherTBoundaryEdge_t_CellEqualTBoundaryEdge_t_t,0);
    return vresult;
}


static VALUE
_wrap_BoundaryComplex_faces_set(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Face_Hash_T *arg2 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Face_Hash_T *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_hash_setTBoundaryFace_p_CellHasherTBoundaryFace_t_CellEqualTBoundaryFace_t_t, 1);
    if (arg1) (arg1)->faces = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryComplex_faces_get(int argc, VALUE *argv, VALUE self) {
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *arg1 = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *) 0 ;
    CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Face_Hash_T *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 1);
    result = (CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Face_Hash_T *)& ((arg1)->faces);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_hash_setTBoundaryFace_p_CellHasherTBoundaryFace_t_CellEqualTBoundaryFace_t_t,0);
    return vresult;
}


static VALUE
_wrap_BoundaryMesh_beziermesh_set(int argc, VALUE *argv, VALUE self) {
    BoundaryMesh *arg1 = (BoundaryMesh *) 0 ;
    BezierMesh *arg2 = (BezierMesh *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierMesh, 1);
    if (arg1) (arg1)->beziermesh = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BoundaryMesh_beziermesh_get(int argc, VALUE *argv, VALUE self) {
    BoundaryMesh *arg1 = (BoundaryMesh *) 0 ;
    BezierMesh *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryMesh, 1);
    result = (BezierMesh *) ((arg1)->beziermesh);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierMesh,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_BoundaryMesh_allocate(VALUE self) {
#else
    static VALUE
    _wrap_BoundaryMesh_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_BoundaryMesh);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_BoundaryMesh(int argc, VALUE *argv, VALUE self) {
    BoundaryMesh *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (BoundaryMesh *)new BoundaryMesh();
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_BoundaryMesh_add_boundary_vertex(int argc, VALUE *argv, VALUE self) {
    BoundaryMesh *arg1 = (BoundaryMesh *) 0 ;
    Point2D *arg2 = 0 ;
    BoundaryVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (BoundaryVertex *)(arg1)->add_boundary_vertex((Point2D const &)*arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryVertex,0);
    return vresult;
}


static VALUE
_wrap_BoundaryMesh_add_boundary_edge__SWIG_0(int argc, VALUE *argv, VALUE self) {
    BoundaryMesh *arg1 = (BoundaryMesh *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    BoundaryVertex *arg3 = (BoundaryVertex *) 0 ;
    vector<Point2D > *arg4 = 0 ;
    vector<double > *arg5 = 0 ;
    int arg6 ;
    int arg7 ;
    double arg8 ;
    BoundaryEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 7) || (argc > 7))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_vectorTPoint2D_t, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_vectorTdouble_t, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg6 = NUM2INT(argv[4]);
    arg7 = NUM2INT(argv[5]);
    arg8 = (double) NUM2DBL(argv[6]);
    result = (BoundaryEdge *)(arg1)->add_boundary_edge(arg2,arg3,(vector<Point2D > const &)*arg4,(vector<double > const &)*arg5,arg6,arg7,arg8);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryEdge,0);
    return vresult;
}


static VALUE
_wrap_BoundaryMesh_add_boundary_edge__SWIG_1(int argc, VALUE *argv, VALUE self) {
    BoundaryMesh *arg1 = (BoundaryMesh *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    BoundaryVertex *arg3 = (BoundaryVertex *) 0 ;
    vector<Point2D > *arg4 = 0 ;
    vector<double > *arg5 = 0 ;
    BoundaryEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_vectorTPoint2D_t, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_vectorTdouble_t, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (BoundaryEdge *)(arg1)->add_boundary_edge(arg2,arg3,(vector<Point2D > const &)*arg4,(vector<double > const &)*arg5);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryEdge,0);
    return vresult;
}


static VALUE _wrap_BoundaryMesh_add_boundary_edge(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[9];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 8); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 5) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BoundaryMesh, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    {
                        void *ptr;
                        _v = (NIL_P(argv[3]) || (TYPE(argv[3]) == T_DATA && SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_vectorTPoint2D_t, 0) != -1)) ? 1 : 0;
                    }
                    if (_v) {
                        {
                            void *ptr;
                            _v = (NIL_P(argv[4]) || (TYPE(argv[4]) == T_DATA && SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_vectorTdouble_t, 0) != -1)) ? 1 : 0;
                        }
                        if (_v) {
                            return _wrap_BoundaryMesh_add_boundary_edge__SWIG_1(nargs, args, self);
                        }
                    }
                }
            }
        }
    }
    if (argc == 8) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BoundaryMesh, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    {
                        void *ptr;
                        _v = (NIL_P(argv[3]) || (TYPE(argv[3]) == T_DATA && SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_vectorTPoint2D_t, 0) != -1)) ? 1 : 0;
                    }
                    if (_v) {
                        {
                            void *ptr;
                            _v = (NIL_P(argv[4]) || (TYPE(argv[4]) == T_DATA && SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_vectorTdouble_t, 0) != -1)) ? 1 : 0;
                        }
                        if (_v) {
                            {
                                _v = ((TYPE(argv[5]) == T_FIXNUM) || (TYPE(argv[5]) == T_BIGNUM)) ? 1 : 0;
                            }
                            if (_v) {
                                {
                                    _v = ((TYPE(argv[6]) == T_FIXNUM) || (TYPE(argv[6]) == T_BIGNUM)) ? 1 : 0;
                                }
                                if (_v) {
                                    {
                                        _v = ((TYPE(argv[7]) == T_FLOAT) || (TYPE(argv[7]) == T_FIXNUM) || (TYPE(argv[7]) == T_BIGNUM)) ? 1 : 0;
                                    }
                                    if (_v) {
                                        return _wrap_BoundaryMesh_add_boundary_edge__SWIG_0(nargs, args, self);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BoundaryMesh_add_boundary_edge'");
    return Qnil;
}


static VALUE
_wrap_BoundaryMesh_add_boundary_face(int argc, VALUE *argv, VALUE self) {
    BoundaryMesh *arg1 = (BoundaryMesh *) 0 ;
    vector<BoundaryEdge * > *arg2 = 0 ;
    double arg3 ;
    int arg4 ;
    BoundaryFace *result;
    VALUE vresult = Qnil;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTBoundaryEdge_p_t, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg3 = (double) NUM2DBL(argv[1]);
    arg4 = NUM2INT(argv[2]);
    result = (BoundaryFace *)(arg1)->add_boundary_face((vector<BoundaryEdge * > const &)*arg2,arg3,arg4);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryFace,0);
    return vresult;
}


static VALUE
_wrap_BoundaryMesh_bbox(int argc, VALUE *argv, VALUE self) {
    BoundaryMesh *arg1 = (BoundaryMesh *) 0 ;
    Point2D *arg2 = 0 ;
    Point2D *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BoundaryMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Point2D, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->bbox(*arg2,*arg3);
    
    return Qnil;
}


static void
free_BoundaryMesh(BoundaryMesh *arg1) {
    delete arg1;
}
static VALUE
_wrap_BezierMesh_boundarymesh_set(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BoundaryMesh *arg2 = (BoundaryMesh *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryMesh, 1);
    if (arg1) (arg1)->boundarymesh = arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierMesh_boundarymesh_get(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BoundaryMesh *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    result = (BoundaryMesh *) ((arg1)->boundarymesh);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryMesh,0);
    return vresult;
}


static VALUE
_wrap_BezierMesh_en_vertex_vector_set(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    vector<BezierVertex * > *arg2 = (vector<BezierVertex * > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTBezierVertex_p_t, 1);
    if (arg1) (arg1)->en_vertex_vector = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierMesh_en_vertex_vector_get(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    vector<BezierVertex * > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    result = (vector<BezierVertex * > *)& ((arg1)->en_vertex_vector);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTBezierVertex_p_t,0);
    return vresult;
}


static VALUE
_wrap_BezierMesh_en_edge_vector_set(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    vector<BezierEdge * > *arg2 = (vector<BezierEdge * > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTBezierEdge_p_t, 1);
    if (arg1) (arg1)->en_edge_vector = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierMesh_en_edge_vector_get(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    vector<BezierEdge * > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    result = (vector<BezierEdge * > *)& ((arg1)->en_edge_vector);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTBezierEdge_p_t,0);
    return vresult;
}


static VALUE
_wrap_BezierMesh_en_face_vector_set(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    vector<BezierTriangle * > *arg2 = (vector<BezierTriangle * > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTBezierTriangle_p_t, 1);
    if (arg1) (arg1)->en_face_vector = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierMesh_en_face_vector_get(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    vector<BezierTriangle * > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    result = (vector<BezierTriangle * > *)& ((arg1)->en_face_vector);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTBezierTriangle_p_t,0);
    return vresult;
}


static VALUE
_wrap_BezierMesh_en_bedge_vector_set(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    vector<BezierEdge * > *arg2 = (vector<BezierEdge * > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTBezierEdge_p_t, 1);
    if (arg1) (arg1)->en_bedge_vector = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_BezierMesh_en_bedge_vector_get(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    vector<BezierEdge * > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    result = (vector<BezierEdge * > *)& ((arg1)->en_bedge_vector);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTBezierEdge_p_t,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_BezierMesh_allocate(VALUE self) {
#else
    static VALUE
    _wrap_BezierMesh_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_BezierMesh);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_BezierMesh(int argc, VALUE *argv, VALUE self) {
    BezierMesh *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (BezierMesh *)new BezierMesh();
    DATA_PTR(self) = result;
    return self;
}


static void
free_BezierMesh(BezierMesh *arg1) {
    delete arg1;
}
static VALUE
_wrap_BezierMesh_set_linear_flips(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    bool arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    arg2 = RTEST(argv[0]);
    (arg1)->set_linear_flips(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BezierMesh_add_bezier_vertex__SWIG_0(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    Point2D *arg2 = 0 ;
    BezierVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (BezierVertex *)(arg1)->add_bezier_vertex((Point2D const &)*arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierVertex,0);
    return vresult;
}


static VALUE
_wrap_BezierMesh_add_bezier_vertex__SWIG_1(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    Point2D *arg2 = 0 ;
    LinearData *arg3 = 0 ;
    BezierVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_LinearData, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (BezierVertex *)(arg1)->add_bezier_vertex((Point2D const &)*arg2,(LinearData const &)*arg3);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierVertex,0);
    return vresult;
}


static VALUE
_wrap_BezierMesh_add_bezier_vertex__SWIG_2(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    ControlPoint arg2 ;
    BezierVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    {
        ControlPoint * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_ControlPoint, 1);
        if (ptr) arg2 = *ptr;
    }
    result = (BezierVertex *)(arg1)->add_bezier_vertex(arg2);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierVertex,0);
    return vresult;
}


static VALUE
_wrap_BezierMesh_add_bezier_vertex__SWIG_3(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    ControlPoint arg2 ;
    LinearData *arg3 = 0 ;
    BezierVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    {
        ControlPoint * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_ControlPoint, 1);
        if (ptr) arg2 = *ptr;
    }
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_LinearData, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (BezierVertex *)(arg1)->add_bezier_vertex(arg2,(LinearData const &)*arg3);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierVertex,0);
    return vresult;
}


static VALUE _wrap_BezierMesh_add_bezier_vertex(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierMesh, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_Point2D, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BezierMesh_add_bezier_vertex__SWIG_0(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierMesh, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_ControlPoint, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_BezierMesh_add_bezier_vertex__SWIG_2(nargs, args, self);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierMesh, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_Point2D, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_LinearData, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierMesh_add_bezier_vertex__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierMesh, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_ControlPoint, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_LinearData, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_BezierMesh_add_bezier_vertex__SWIG_3(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BezierMesh_add_bezier_vertex'");
    return Qnil;
}


static VALUE
_wrap_BezierMesh_add_bezier_edge__SWIG_0(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    Point2D *arg2 = 0 ;
    BezierVertex *arg3 = (BezierVertex *) 0 ;
    BezierVertex *arg4 = (BezierVertex *) 0 ;
    BezierEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_BezierVertex, 1);
    result = (BezierEdge *)(arg1)->add_bezier_edge((Point2D const &)*arg2,arg3,arg4);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierEdge,0);
    return vresult;
}


static VALUE
_wrap_BezierMesh_add_bezier_edge__SWIG_1(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    Point2D *arg2 = 0 ;
    LinearData *arg3 = 0 ;
    BezierVertex *arg4 = (BezierVertex *) 0 ;
    BezierVertex *arg5 = (BezierVertex *) 0 ;
    BezierEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_LinearData, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_BezierVertex, 1);
    result = (BezierEdge *)(arg1)->add_bezier_edge((Point2D const &)*arg2,(LinearData const &)*arg3,arg4,arg5);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierEdge,0);
    return vresult;
}


static VALUE
_wrap_BezierMesh_add_bezier_edge__SWIG_2(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    ControlPoint arg2 ;
    BezierVertex *arg3 = (BezierVertex *) 0 ;
    BezierVertex *arg4 = (BezierVertex *) 0 ;
    BezierEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    {
        ControlPoint * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_ControlPoint, 1);
        if (ptr) arg2 = *ptr;
    }
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_BezierVertex, 1);
    result = (BezierEdge *)(arg1)->add_bezier_edge(arg2,arg3,arg4);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierEdge,0);
    return vresult;
}


static VALUE
_wrap_BezierMesh_add_bezier_edge__SWIG_3(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    ControlPoint arg2 ;
    LinearData *arg3 = 0 ;
    BezierVertex *arg4 = (BezierVertex *) 0 ;
    BezierVertex *arg5 = (BezierVertex *) 0 ;
    BezierEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    {
        ControlPoint * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_ControlPoint, 1);
        if (ptr) arg2 = *ptr;
    }
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_LinearData, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_BezierVertex, 1);
    result = (BezierEdge *)(arg1)->add_bezier_edge(arg2,(LinearData const &)*arg3,arg4,arg5);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierEdge,0);
    return vresult;
}


static VALUE _wrap_BezierMesh_add_bezier_edge(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[6];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 5); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierMesh, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_Point2D, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    {
                        void *ptr;
                        _v = (NIL_P(argv[3]) || (TYPE(argv[3]) == T_DATA && SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
                    }
                    if (_v) {
                        return _wrap_BezierMesh_add_bezier_edge__SWIG_0(nargs, args, self);
                    }
                }
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierMesh, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_ControlPoint, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    {
                        void *ptr;
                        _v = (NIL_P(argv[3]) || (TYPE(argv[3]) == T_DATA && SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
                    }
                    if (_v) {
                        return _wrap_BezierMesh_add_bezier_edge__SWIG_2(nargs, args, self);
                    }
                }
            }
        }
    }
    if (argc == 5) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierMesh, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_Point2D, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_LinearData, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    {
                        void *ptr;
                        _v = (NIL_P(argv[3]) || (TYPE(argv[3]) == T_DATA && SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
                    }
                    if (_v) {
                        {
                            void *ptr;
                            _v = (NIL_P(argv[4]) || (TYPE(argv[4]) == T_DATA && SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
                        }
                        if (_v) {
                            return _wrap_BezierMesh_add_bezier_edge__SWIG_1(nargs, args, self);
                        }
                    }
                }
            }
        }
    }
    if (argc == 5) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierMesh, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_ControlPoint, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_LinearData, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    {
                        void *ptr;
                        _v = (NIL_P(argv[3]) || (TYPE(argv[3]) == T_DATA && SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
                    }
                    if (_v) {
                        {
                            void *ptr;
                            _v = (NIL_P(argv[4]) || (TYPE(argv[4]) == T_DATA && SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
                        }
                        if (_v) {
                            return _wrap_BezierMesh_add_bezier_edge__SWIG_3(nargs, args, self);
                        }
                    }
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'BezierMesh_add_bezier_edge'");
    return Qnil;
}


static VALUE
_wrap_BezierMesh_add_bezier_triangle(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    BezierEdge *arg3 = (BezierEdge *) 0 ;
    BezierEdge *arg4 = (BezierEdge *) 0 ;
    BezierEdge *arg5 = (BezierEdge *) 0 ;
    BezierTriangle *result;
    VALUE vresult = Qnil;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_BezierEdge, 1);
    result = (BezierTriangle *)(arg1)->add_bezier_triangle(arg2,arg3,arg4,arg5);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierTriangle,0);
    return vresult;
}


static VALUE
_wrap_BezierMesh_clean_insert_point(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    double arg3 ;
    double arg4 ;
    BezierVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    arg3 = (double) NUM2DBL(argv[1]);
    arg4 = (double) NUM2DBL(argv[2]);
    result = (BezierVertex *)(arg1)->clean_insert_point(arg2,arg3,arg4);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierVertex,0);
    return vresult;
}


static VALUE
_wrap_BezierMesh_clean_insert_edge_midpoint(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    double arg3 ;
    BezierVertex *result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    arg3 = (double) NUM2DBL(argv[1]);
    result = (BezierVertex *)(arg1)->clean_insert_edge_midpoint(arg2,arg3);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierVertex,0);
    return vresult;
}


static VALUE
_wrap_BezierMesh_remove_vertex(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    BezierTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    result = (arg1)->remove_vertex(arg2);
    
    {
        BezierTuple * resultptr;
        resultptr = new BezierTuple((BezierTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierMesh_smooth_edge(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    (arg1)->smooth_edge(arg2);
    
    return Qnil;
}


static VALUE
_wrap_BezierMesh_flip(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    BezierTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    result = (arg1)->flip(arg2);
    
    {
        BezierTuple * resultptr;
        resultptr = new BezierTuple((BezierTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierMesh_should_flip(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    result = (bool)(arg1)->should_flip(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BezierMesh_can_flip(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    result = (bool)(arg1)->can_flip(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BezierMesh_can_smooth(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    result = (bool)(arg1)->can_smooth(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_BezierMesh_blind_locate_point(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    Point2D arg2 ;
    BezierTriangle **arg3 = 0 ;
    BezierEdge **arg4 = 0 ;
    double *arg5 = 0 ;
    double *arg6 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 5) || (argc > 5))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    {
        Point2D * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_Point2D, 1);
        if (ptr) arg2 = *ptr;
    }
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_p_BezierTriangle, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_p_BezierEdge, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_double, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[4], (void **) &arg6, SWIGTYPE_p_double, 1); if (arg6 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->blind_locate_point(arg2,*arg3,*arg4,*arg5,*arg6);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BezierMesh_locate_point(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    Point2D arg2 ;
    BezierTriangle *arg3 = (BezierTriangle *) 0 ;
    bool arg4 ;
    BezierTriangle **arg5 = 0 ;
    BezierEdge **arg6 = 0 ;
    double *arg7 = 0 ;
    double *arg8 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 7) || (argc > 7))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    {
        Point2D * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_Point2D, 1);
        if (ptr) arg2 = *ptr;
    }
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierTriangle, 1);
    arg4 = RTEST(argv[2]);
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_p_BezierTriangle, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[4], (void **) &arg6, SWIGTYPE_p_p_BezierEdge, 1); if (arg6 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[5], (void **) &arg7, SWIGTYPE_p_double, 1); if (arg7 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[6], (void **) &arg8, SWIGTYPE_p_double, 1); if (arg8 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->locate_point(arg2,arg3,arg4,*arg5,*arg6,*arg7,*arg8);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_BezierMesh_enumerate(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    (arg1)->enumerate();
    
    return Qnil;
}


static VALUE
_wrap_BezierMesh_en_vertex(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    int arg2 ;
    BezierVertex result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    arg2 = NUM2INT(argv[0]);
    result = (arg1)->en_vertex(arg2);
    
    {
        BezierVertex * resultptr;
        resultptr = new BezierVertex((BezierVertex &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierVertex, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierMesh_en_edge(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    int arg2 ;
    BezierEdge result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    arg2 = NUM2INT(argv[0]);
    result = (arg1)->en_edge(arg2);
    
    {
        BezierEdge * resultptr;
        resultptr = new BezierEdge((BezierEdge &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierEdge, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierMesh_en_face(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    int arg2 ;
    SwigValueWrapper< BezierTriangle > result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    arg2 = NUM2INT(argv[0]);
    result = (arg1)->en_face(arg2);
    
    {
        BezierTriangle * resultptr;
        resultptr = new BezierTriangle((BezierTriangle &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierTriangle, 1);
    }
    return vresult;
}


static VALUE
_wrap_BezierMesh_en_bedge(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    int arg2 ;
    BezierEdge result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    arg2 = NUM2INT(argv[0]);
    result = (arg1)->en_bedge(arg2);
    
    {
        BezierEdge * resultptr;
        resultptr = new BezierEdge((BezierEdge &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierEdge, 1);
    }
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_MeshInput_allocate(VALUE self) {
#else
    static VALUE
    _wrap_MeshInput_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_MeshInput);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_MeshInput(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BoundaryMesh *arg2 = (BoundaryMesh *) 0 ;
    MeshInput *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_BoundaryMesh, 1);
    result = (MeshInput *)new MeshInput(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_MeshInput_read(int argc, VALUE *argv, VALUE self) {
    MeshInput *arg1 = (MeshInput *) 0 ;
    char *arg2 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_MeshInput, 1);
    arg2 = StringValuePtr(argv[0]);
    result = (bool)(arg1)->read(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static void
free_MeshInput(MeshInput *arg1) {
    delete arg1;
}
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_MeshOutput_allocate(VALUE self) {
#else
    static VALUE
    _wrap_MeshOutput_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_MeshOutput);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_MeshOutput(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BoundaryMesh *arg2 = (BoundaryMesh *) 0 ;
    MeshOutput *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_BoundaryMesh, 1);
    result = (MeshOutput *)new MeshOutput(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_MeshOutput_write(int argc, VALUE *argv, VALUE self) {
    MeshOutput *arg1 = (MeshOutput *) 0 ;
    char *arg2 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_MeshOutput, 1);
    arg2 = StringValuePtr(argv[0]);
    result = (bool)(arg1)->write(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static void
free_MeshOutput(MeshOutput *arg1) {
    delete arg1;
}
static VALUE
_wrap_Simulation_bdry_mesh_set(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    BoundaryMesh *arg2 = (BoundaryMesh *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryMesh, 1);
    if (arg1) (arg1)->bdry_mesh = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Simulation_bdry_mesh_get(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    BoundaryMesh *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    result = (BoundaryMesh *)& ((arg1)->bdry_mesh);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryMesh,0);
    return vresult;
}


static VALUE
_wrap_Simulation_bezier_mesh_set(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    BezierMesh *arg2 = (BezierMesh *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierMesh, 1);
    if (arg1) (arg1)->bezier_mesh = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Simulation_bezier_mesh_get(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    BezierMesh *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    result = (BezierMesh *)& ((arg1)->bezier_mesh);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierMesh,0);
    return vresult;
}


static VALUE
_wrap_Simulation_timekeeper_set(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    TimeKeeper arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    {
        TimeKeeper * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_TimeKeeper, 1);
        if (ptr) arg2 = *ptr;
    }
    if (arg1) (arg1)->timekeeper = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Simulation_timekeeper_get(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    TimeKeeper result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    result =  ((arg1)->timekeeper);
    
    {
        TimeKeeper * resultptr;
        resultptr = new TimeKeeper((TimeKeeper &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_TimeKeeper, 1);
    }
    return vresult;
}


static VALUE
_wrap_new_Simulation__SWIG_0(int argc, VALUE *argv, VALUE self) {
    char *arg1 ;
    Simulation *result;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    arg1 = StringValuePtr(argv[0]);
    result = (Simulation *)new Simulation(arg1);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_Simulation__SWIG_1(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BoundaryMesh *arg2 = (BoundaryMesh *) 0 ;
    Simulation *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_BoundaryMesh, 1);
    result = (Simulation *)new Simulation(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Simulation_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Simulation_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Simulation);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Simulation__SWIG_2(int argc, VALUE *argv, VALUE self) {
    Simulation *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (Simulation *)new Simulation();
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_Simulation(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[2];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_Simulation__SWIG_2(nargs, args, self);
    }
    if (argc == 1) {
        int _v;
        {
            _v = (TYPE(argv[0]) == T_STRING) ? 1 : 0;
        }
        if (_v) {
            return _wrap_new_Simulation__SWIG_0(nargs, args, self);
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierMesh, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryMesh, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_Simulation__SWIG_1(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_Simulation'");
    return Qnil;
}


static VALUE
_wrap_Simulation_get_bezier_mesh(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    BezierMesh *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    result = (BezierMesh *)(arg1)->get_bezier_mesh();
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierMesh,0);
    return vresult;
}


static VALUE
_wrap_Simulation_get_boundary_mesh(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    BoundaryMesh *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    result = (BoundaryMesh *)(arg1)->get_boundary_mesh();
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryMesh,0);
    return vresult;
}


static VALUE
_wrap_Simulation_move__SWIG_0(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    double arg2 ;
    unsigned int arg3 ;
    unsigned int arg4 ;
    bool arg5 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = NUM2UINT(argv[1]);
    arg4 = NUM2UINT(argv[2]);
    arg5 = RTEST(argv[3]);
    (arg1)->move(arg2,arg3,arg4,arg5);
    
    return Qnil;
}


static VALUE
_wrap_Simulation_move__SWIG_1(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    double arg2 ;
    unsigned int arg3 ;
    unsigned int arg4 ;
    unsigned int arg5 ;
    unsigned int arg6 ;
    bool arg7 ;
    
    if ((argc < 6) || (argc > 6))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    arg3 = NUM2UINT(argv[1]);
    arg4 = NUM2UINT(argv[2]);
    arg5 = NUM2UINT(argv[3]);
    arg6 = NUM2UINT(argv[4]);
    arg7 = RTEST(argv[5]);
    (arg1)->move(arg2,arg3,arg4,arg5,arg6,arg7);
    
    return Qnil;
}


static VALUE _wrap_Simulation_move(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[8];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 7); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 5) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Simulation, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FLOAT) || (TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    {
                        _v = ((TYPE(argv[3]) == T_FIXNUM) || (TYPE(argv[3]) == T_BIGNUM)) ? 1 : 0;
                    }
                    if (_v) {
                        {
                            _v = (argv[4] == Qtrue || argv[4] == Qfalse) ? 1 : 0;
                        }
                        if (_v) {
                            return _wrap_Simulation_move__SWIG_0(nargs, args, self);
                        }
                    }
                }
            }
        }
    }
    if (argc == 7) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Simulation, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FLOAT) || (TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    {
                        _v = ((TYPE(argv[3]) == T_FIXNUM) || (TYPE(argv[3]) == T_BIGNUM)) ? 1 : 0;
                    }
                    if (_v) {
                        {
                            _v = ((TYPE(argv[4]) == T_FIXNUM) || (TYPE(argv[4]) == T_BIGNUM)) ? 1 : 0;
                        }
                        if (_v) {
                            {
                                _v = ((TYPE(argv[5]) == T_FIXNUM) || (TYPE(argv[5]) == T_BIGNUM)) ? 1 : 0;
                            }
                            if (_v) {
                                {
                                    _v = (argv[6] == Qtrue || argv[6] == Qfalse) ? 1 : 0;
                                }
                                if (_v) {
                                    return _wrap_Simulation_move__SWIG_1(nargs, args, self);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'Simulation_move'");
    return Qnil;
}


static VALUE
_wrap_Simulation_clean(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    char *arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    arg2 = StringValuePtr(argv[0]);
    (arg1)->clean(arg2);
    
    return Qnil;
}


static VALUE
_wrap_Simulation_to_file(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    char *arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    arg2 = StringValuePtr(argv[0]);
    result = (int)(arg1)->to_file(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Simulation_to_eps(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    char *arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    arg2 = StringValuePtr(argv[0]);
    result = (int)(arg1)->to_eps(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Simulation_start_logging(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    char *arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    arg2 = StringValuePtr(argv[0]);
    result = (int)(arg1)->start_logging(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Simulation_print(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    (arg1)->print();
    
    return Qnil;
}


static VALUE
_wrap_Simulation_print_statistics(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    (arg1)->print_statistics();
    
    return Qnil;
}


static VALUE
_wrap_Simulation_print_times(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    (arg1)->print_times();
    
    return Qnil;
}


static void
free_Simulation(Simulation *arg1) {
    delete arg1;
}
static VALUE
_wrap_Visualization_world_top_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *arg2 = (Point2D *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1);
    if (arg1) (arg1)->world_top = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_world_top_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (Point2D *)& ((arg1)->world_top);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Point2D,0);
    return vresult;
}


static VALUE
_wrap_Visualization_world_bot_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *arg2 = (Point2D *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1);
    if (arg1) (arg1)->world_bot = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_world_bot_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (Point2D *)& ((arg1)->world_bot);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Point2D,0);
    return vresult;
}


static VALUE
_wrap_Visualization_world_center_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *arg2 = (Point2D *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1);
    if (arg1) (arg1)->world_center = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_world_center_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (Point2D *)& ((arg1)->world_center);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Point2D,0);
    return vresult;
}


static VALUE
_wrap_Visualization_world_width_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->world_width = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_world_width_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (double) ((arg1)->world_width);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Visualization_world_height_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->world_height = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_world_height_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (double) ((arg1)->world_height);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Visualization_world_ratio_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->world_ratio = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_world_ratio_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (double) ((arg1)->world_ratio);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Visualization_zoom_top_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *arg2 = (Point2D *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1);
    if (arg1) (arg1)->zoom_top = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_zoom_top_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (Point2D *)& ((arg1)->zoom_top);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Point2D,0);
    return vresult;
}


static VALUE
_wrap_Visualization_zoom_bot_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *arg2 = (Point2D *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1);
    if (arg1) (arg1)->zoom_bot = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_zoom_bot_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (Point2D *)& ((arg1)->zoom_bot);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Point2D,0);
    return vresult;
}


static VALUE
_wrap_Visualization_zoom_center_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *arg2 = (Point2D *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1);
    if (arg1) (arg1)->zoom_center = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_zoom_center_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (Point2D *)& ((arg1)->zoom_center);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Point2D,0);
    return vresult;
}


static VALUE
_wrap_Visualization_zoom_width_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->zoom_width = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_zoom_width_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (double) ((arg1)->zoom_width);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Visualization_zoom_height_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->zoom_height = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_zoom_height_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (double) ((arg1)->zoom_height);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Visualization_zoom_ratio_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->zoom_ratio = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_zoom_ratio_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (double) ((arg1)->zoom_ratio);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Visualization_zoomed_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    bool arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = RTEST(argv[0]);
    if (arg1) (arg1)->zoomed = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_zoomed_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (bool) ((arg1)->zoomed);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Visualization_view_top_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *arg2 = (Point2D *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1);
    if (arg1) (arg1)->view_top = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_view_top_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (Point2D *)& ((arg1)->view_top);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Point2D,0);
    return vresult;
}


static VALUE
_wrap_Visualization_view_bot_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *arg2 = (Point2D *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1);
    if (arg1) (arg1)->view_bot = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_view_bot_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (Point2D *)& ((arg1)->view_bot);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Point2D,0);
    return vresult;
}


static VALUE
_wrap_Visualization_screen_width_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->screen_width = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_screen_width_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (int) ((arg1)->screen_width);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Visualization_screen_height_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->screen_height = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_screen_height_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (int) ((arg1)->screen_height);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Visualization_screen_ratio_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->screen_ratio = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_screen_ratio_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (double) ((arg1)->screen_ratio);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Visualization_colormap_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    ColorMap *arg2 = (ColorMap *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_ColorMap, 1);
    if (arg1) (arg1)->colormap = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_colormap_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    ColorMap *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (ColorMap *)& ((arg1)->colormap);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_ColorMap,0);
    return vresult;
}


static VALUE
_wrap_Visualization_bezier_mesh_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierMesh *arg2 = (BezierMesh *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierMesh, 1);
    if (arg1) (arg1)->bezier_mesh = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_bezier_mesh_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierMesh *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (BezierMesh *) ((arg1)->bezier_mesh);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BezierMesh,0);
    return vresult;
}


static VALUE
_wrap_Visualization_bdry_mesh_set(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BoundaryMesh *arg2 = (BoundaryMesh *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryMesh, 1);
    if (arg1) (arg1)->bdry_mesh = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Visualization_bdry_mesh_get(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BoundaryMesh *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    result = (BoundaryMesh *) ((arg1)->bdry_mesh);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryMesh,0);
    return vresult;
}


static VALUE
_wrap_new_Visualization__SWIG_0(int argc, VALUE *argv, VALUE self) {
    Simulation *arg1 = (Simulation *) 0 ;
    int arg2 ;
    int arg3 ;
    Visualization *result;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_Simulation, 1);
    arg2 = NUM2INT(argv[1]);
    arg3 = NUM2INT(argv[2]);
    result = (Visualization *)new Visualization(arg1,arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_new_Visualization__SWIG_1(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BoundaryMesh *arg2 = (BoundaryMesh *) 0 ;
    int arg3 ;
    int arg4 ;
    Visualization *result;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_BoundaryMesh, 1);
    arg3 = NUM2INT(argv[2]);
    arg4 = NUM2INT(argv[3]);
    result = (Visualization *)new Visualization(arg1,arg2,arg3,arg4);
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Visualization_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Visualization_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Visualization);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Visualization__SWIG_2(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BoundaryMesh *arg2 = (BoundaryMesh *) 0 ;
    Visualization *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_BoundaryMesh, 1);
    result = (Visualization *)new Visualization(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_Visualization(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 4); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierMesh, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryMesh, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_new_Visualization__SWIG_2(nargs, args, self);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Simulation, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_new_Visualization__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_BezierMesh, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryMesh, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    {
                        _v = ((TYPE(argv[3]) == T_FIXNUM) || (TYPE(argv[3]) == T_BIGNUM)) ? 1 : 0;
                    }
                    if (_v) {
                        return _wrap_new_Visualization__SWIG_1(nargs, args, self);
                    }
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_Visualization'");
    return Qnil;
}


static void
free_Visualization(Visualization *arg1) {
    delete arg1;
}
static VALUE
_wrap_Visualization_load_color_map(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    char *arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = StringValuePtr(argv[0]);
    result = (int)(arg1)->load_color_map(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Visualization_map_color(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    int arg2 ;
    Color *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = NUM2INT(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->map_color(arg2,(Color const &)*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Visualization_write_jpeg(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    char *arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = StringValuePtr(argv[0]);
    result = (int)(arg1)->write_jpeg(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Visualization_write_tiff(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    char *arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = StringValuePtr(argv[0]);
    result = (int)(arg1)->write_tiff(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Visualization_write_ppm(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    char *arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = StringValuePtr(argv[0]);
    result = (int)(arg1)->write_ppm(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Visualization_resize(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    int arg2 ;
    int arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    (arg1)->resize(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_compute_world_size(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    (arg1)->compute_world_size();
    
    return Qnil;
}


static VALUE
_wrap_Visualization_project(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    (arg1)->project();
    
    return Qnil;
}


static VALUE
_wrap_Visualization_convert_from_screen_coords(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    int arg2 ;
    int arg3 ;
    Point2D result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = NUM2INT(argv[1]);
    result = (arg1)->convert_from_screen_coords(arg2,arg3);
    
    {
        Point2D * resultptr;
        resultptr = new Point2D((Point2D &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_Point2D, 1);
    }
    return vresult;
}


static VALUE
_wrap_Visualization_zoomin(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D arg2 ;
    Point2D arg3 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    {
        Point2D * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_Point2D, 1);
        if (ptr) arg2 = *ptr;
    }
    {
        Point2D * ptr;
        SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_Point2D, 1);
        if (ptr) arg3 = *ptr;
    }
    (arg1)->zoomin(arg2,arg3);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_zoomout(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    (arg1)->zoomout();
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Color *arg2 = 0 ;
    Color *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Color, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw((Color const &)*arg2,(Color const &)*arg3);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_bezier(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Color *arg2 = 0 ;
    Color *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Color, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_bezier((Color const &)*arg2,(Color const &)*arg3);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_solid(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Color *arg2 = 0 ;
    Color *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Color, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_solid((Color const &)*arg2,(Color const &)*arg3);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_data(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Color *arg2 = 0 ;
    Color *arg3 = 0 ;
    unsigned int arg4 ;
    unsigned int arg5 ;
    unsigned int arg6 ;
    
    if ((argc < 5) || (argc > 5))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Color, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg4 = NUM2UINT(argv[2]);
    arg5 = NUM2UINT(argv[3]);
    arg6 = NUM2UINT(argv[4]);
    (arg1)->draw_data((Color const &)*arg2,(Color const &)*arg3,arg4,arg5,arg6);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_debug__SWIG_0(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Color *arg2 = 0 ;
    Color *arg3 = 0 ;
    Color *arg4 = 0 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Color, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_Color, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_debug((Color const &)*arg2,(Color const &)*arg3,(Color const &)*arg4);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_debug__SWIG_1(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Color *arg2 = 0 ;
    Color *arg3 = 0 ;
    Color *arg4 = 0 ;
    Color *arg5 = 0 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Color, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_Color, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_Color, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_debug((Color const &)*arg2,(Color const &)*arg3,(Color const &)*arg4,(Color const &)*arg5);
    
    return Qnil;
}


static VALUE _wrap_Visualization_draw_debug(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[6];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 5); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Visualization, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    {
                        void *ptr;
                        _v = (NIL_P(argv[3]) || (TYPE(argv[3]) == T_DATA && SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
                    }
                    if (_v) {
                        return _wrap_Visualization_draw_debug__SWIG_0(nargs, args, self);
                    }
                }
            }
        }
    }
    if (argc == 5) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Visualization, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    {
                        void *ptr;
                        _v = (NIL_P(argv[3]) || (TYPE(argv[3]) == T_DATA && SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
                    }
                    if (_v) {
                        {
                            void *ptr;
                            _v = (NIL_P(argv[4]) || (TYPE(argv[4]) == T_DATA && SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
                        }
                        if (_v) {
                            return _wrap_Visualization_draw_debug__SWIG_1(nargs, args, self);
                        }
                    }
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'Visualization_draw_debug'");
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_bdry_debug(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Color *arg2 = 0 ;
    Color *arg3 = 0 ;
    Color *arg4 = 0 ;
    Color *arg5 = 0 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Color, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_Color, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_Color, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_bdry_debug((Color const &)*arg2,(Color const &)*arg3,(Color const &)*arg4,(Color const &)*arg5);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_tuple(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierTuple *arg2 = 0 ;
    Color *arg3 = 0 ;
    Color *arg4 = 0 ;
    Color *arg5 = 0 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTuple, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_Color, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_Color, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_tuple((BezierTuple const &)*arg2,(Color const &)*arg3,(Color const &)*arg4,(Color const &)*arg5);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_point__SWIG_0(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    double arg3 ;
    double arg4 ;
    Color *arg5 = 0 ;
    Color *arg6 = 0 ;
    
    if ((argc < 5) || (argc > 5))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    arg3 = (double) NUM2DBL(argv[1]);
    arg4 = (double) NUM2DBL(argv[2]);
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_Color, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[4], (void **) &arg6, SWIGTYPE_p_Color, 1); if (arg6 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_point(arg2,arg3,arg4,(Color const &)*arg5,(Color const &)*arg6);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_point__SWIG_1(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    double arg3 ;
    Color *arg4 = 0 ;
    Color *arg5 = 0 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    arg3 = (double) NUM2DBL(argv[1]);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_Color, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_Color, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_point(arg2,arg3,(Color const &)*arg4,(Color const &)*arg5);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_point__SWIG_2(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *arg2 = 0 ;
    Color *arg3 = 0 ;
    double arg4 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    arg4 = (double) NUM2DBL(argv[2]);
    (arg1)->draw_point((Point2D const &)*arg2,(Color const &)*arg3,arg4);
    
    return Qnil;
}


static VALUE _wrap_Visualization_draw_point(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[7];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 6); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 4) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Visualization, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_Point2D, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    {
                        _v = ((TYPE(argv[3]) == T_FLOAT) || (TYPE(argv[3]) == T_FIXNUM) || (TYPE(argv[3]) == T_BIGNUM)) ? 1 : 0;
                    }
                    if (_v) {
                        return _wrap_Visualization_draw_point__SWIG_2(nargs, args, self);
                    }
                }
            }
        }
    }
    if (argc == 5) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Visualization, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FLOAT) || (TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    {
                        void *ptr;
                        _v = (NIL_P(argv[3]) || (TYPE(argv[3]) == T_DATA && SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
                    }
                    if (_v) {
                        {
                            void *ptr;
                            _v = (NIL_P(argv[4]) || (TYPE(argv[4]) == T_DATA && SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
                        }
                        if (_v) {
                            return _wrap_Visualization_draw_point__SWIG_1(nargs, args, self);
                        }
                    }
                }
            }
        }
    }
    if (argc == 6) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Visualization, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FLOAT) || (TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    {
                        _v = ((TYPE(argv[3]) == T_FLOAT) || (TYPE(argv[3]) == T_FIXNUM) || (TYPE(argv[3]) == T_BIGNUM)) ? 1 : 0;
                    }
                    if (_v) {
                        {
                            void *ptr;
                            _v = (NIL_P(argv[4]) || (TYPE(argv[4]) == T_DATA && SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
                        }
                        if (_v) {
                            {
                                void *ptr;
                                _v = (NIL_P(argv[5]) || (TYPE(argv[5]) == T_DATA && SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
                            }
                            if (_v) {
                                return _wrap_Visualization_draw_point__SWIG_0(nargs, args, self);
                            }
                        }
                    }
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'Visualization_draw_point'");
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_boundary_vertex(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    Color *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_boundary_vertex(arg2,(Color const &)*arg3);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_boundary_edge(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    Color *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_boundary_edge(arg2,(Color const &)*arg3);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_boundary_edge_debug(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    Color *arg3 = 0 ;
    Color *arg4 = 0 ;
    Color *arg5 = 0 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_Color, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_Color, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_boundary_edge_debug(arg2,(Color const &)*arg3,(Color const &)*arg4,(Color const &)*arg5);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_bezier_vertex(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    Color *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_bezier_vertex(arg2,(Color const &)*arg3);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_bezier_edge(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    Color *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_bezier_edge(arg2,(Color const &)*arg3);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_bezier_triangle__SWIG_0(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    (arg1)->draw_bezier_triangle(arg2);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_bezier_triangle__SWIG_1(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    Color *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_bezier_triangle(arg2,(Color const &)*arg3);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_bezier_triangle__SWIG_2(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    unsigned int arg3 ;
    unsigned int arg4 ;
    unsigned int arg5 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    arg3 = NUM2UINT(argv[1]);
    arg4 = NUM2UINT(argv[2]);
    arg5 = NUM2UINT(argv[3]);
    (arg1)->draw_bezier_triangle(arg2,arg3,arg4,arg5);
    
    return Qnil;
}


static VALUE _wrap_Visualization_draw_bezier_triangle(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[6];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 5); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Visualization, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_Visualization_draw_bezier_triangle__SWIG_0(nargs, args, self);
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Visualization, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_Visualization_draw_bezier_triangle__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    if (argc == 5) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Visualization, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    {
                        _v = ((TYPE(argv[3]) == T_FIXNUM) || (TYPE(argv[3]) == T_BIGNUM)) ? 1 : 0;
                    }
                    if (_v) {
                        {
                            _v = ((TYPE(argv[4]) == T_FIXNUM) || (TYPE(argv[4]) == T_BIGNUM)) ? 1 : 0;
                        }
                        if (_v) {
                            return _wrap_Visualization_draw_bezier_triangle__SWIG_2(nargs, args, self);
                        }
                    }
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'Visualization_draw_bezier_triangle'");
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_control_net(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    Color *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_control_net(arg2,(Color const &)*arg3);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_polygon(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *arg2 ;
    int arg3 ;
    Color *arg4 = 0 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1);
    arg3 = NUM2INT(argv[1]);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_Color, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_polygon(arg2,arg3,(Color const &)*arg4);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_smooth_debug(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    Point2D *arg3 ;
    Point2D *arg4 = 0 ;
    Point2D *arg5 = 0 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_Point2D, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_Point2D, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_smooth_debug(arg2,arg3,(Point2D const &)*arg4,(Point2D const &)*arg5);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_draw_flip_debug(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    Point2D *arg3 ;
    Point2D *arg4 = 0 ;
    Point2D *arg5 = 0 ;
    
    if ((argc < 4) || (argc > 4))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Point2D, 1);
    SWIG_ConvertPtr(argv[2], (void **) &arg4, SWIGTYPE_p_Point2D, 1); if (arg4 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[3], (void **) &arg5, SWIGTYPE_p_Point2D, 1); if (arg5 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->draw_flip_debug(arg2,arg3,(Point2D const &)*arg4,(Point2D const &)*arg5);
    
    return Qnil;
}


static VALUE
_wrap_Visualization_start_draw(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    (arg1)->start_draw();
    
    return Qnil;
}


static VALUE
_wrap_Visualization_finish_draw(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    (arg1)->finish_draw();
    
    return Qnil;
}


static VALUE
_wrap_Visualization_is_visible__SWIG_0(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D *arg2 = 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (bool)(arg1)->is_visible((Point2D const &)*arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Visualization_is_visible__SWIG_1(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BoundaryVertex *arg2 = (BoundaryVertex *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryVertex, 1);
    result = (bool)(arg1)->is_visible(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Visualization_is_visible__SWIG_2(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierVertex *arg2 = (BezierVertex *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierVertex, 1);
    result = (bool)(arg1)->is_visible(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Visualization_is_visible__SWIG_3(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierEdge *arg2 = (BezierEdge *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierEdge, 1);
    result = (bool)(arg1)->is_visible(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE
_wrap_Visualization_is_visible__SWIG_4(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    BezierTriangle *arg2 = (BezierTriangle *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BezierTriangle, 1);
    result = (bool)(arg1)->is_visible(arg2);
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static VALUE _wrap_Visualization_is_visible(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[3];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 2); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Visualization, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_Point2D, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_Visualization_is_visible__SWIG_0(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Visualization, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BoundaryVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_Visualization_is_visible__SWIG_1(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Visualization, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierVertex, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_Visualization_is_visible__SWIG_2(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Visualization, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierEdge, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_Visualization_is_visible__SWIG_3(nargs, args, self);
            }
        }
    }
    if (argc == 2) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_Visualization, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                void *ptr;
                _v = (NIL_P(argv[1]) || (TYPE(argv[1]) == T_DATA && SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_BezierTriangle, 0) != -1)) ? 1 : 0;
            }
            if (_v) {
                return _wrap_Visualization_is_visible__SWIG_4(nargs, args, self);
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'Visualization_is_visible'");
    return Qnil;
}


static VALUE
_wrap_Visualization_visual_locate(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    Point2D arg2 ;
    BezierTuple result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    {
        Point2D * ptr;
        SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_Point2D, 1);
        if (ptr) arg2 = *ptr;
    }
    result = (arg1)->visual_locate(arg2);
    
    {
        BezierTuple * resultptr;
        resultptr = new BezierTuple((BezierTuple &)result);
        vresult = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_BezierTuple, 1);
    }
    return vresult;
}


static VALUE
_wrap_Visualization_visual_switch(int argc, VALUE *argv, VALUE self) {
    Visualization *arg1 = (Visualization *) 0 ;
    int arg2 ;
    BezierTuple *arg3 = 0 ;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Visualization, 1);
    arg2 = NUM2INT(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_BezierTuple, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    (arg1)->visual_switch(arg2,*arg3);
    
    return Qnil;
}


static VALUE
_wrap_Color_v_set(int argc, VALUE *argv, VALUE self) {
    Color *arg1 = (Color *) 0 ;
    float *arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Color, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_float, 1);
    {
        int ii;
        float *b = (float *) arg1->v;
        for (ii = 0; ii < 3; ii++) b[ii] = *((float *) arg2 + ii);
    }
    return Qnil;
}


static VALUE
_wrap_Color_v_get(int argc, VALUE *argv, VALUE self) {
    Color *arg1 = (Color *) 0 ;
    float *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Color, 1);
    result = (float *)(float *) ((arg1)->v);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_float,0);
    return vresult;
}


static VALUE
_wrap_new_Color__SWIG_0(int argc, VALUE *argv, VALUE self) {
    Color *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (Color *)new Color();
    DATA_PTR(self) = result;
    return self;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Color_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Color_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Color);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Color__SWIG_1(int argc, VALUE *argv, VALUE self) {
    float arg1 ;
    float arg2 ;
    float arg3 ;
    Color *result;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    arg1 = (float) NUM2DBL(argv[0]);
    arg2 = (float) NUM2DBL(argv[1]);
    arg3 = (float) NUM2DBL(argv[2]);
    result = (Color *)new Color(arg1,arg2,arg3);
    DATA_PTR(self) = result;
    return self;
}


static VALUE _wrap_new_Color(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[3];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 0) {
        return _wrap_new_Color__SWIG_0(nargs, args, self);
    }
    if (argc == 3) {
        int _v;
        {
            _v = ((TYPE(argv[0]) == T_FLOAT) || (TYPE(argv[0]) == T_FIXNUM) || (TYPE(argv[0]) == T_BIGNUM)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FLOAT) || (TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FLOAT) || (TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_new_Color__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'new_Color'");
    return Qnil;
}


static VALUE
_wrap_Color_assign(int argc, VALUE *argv, VALUE self) {
    Color *arg1 = (Color *) 0 ;
    float arg2 ;
    float arg3 ;
    float arg4 ;
    
    if ((argc < 3) || (argc > 3))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Color, 1);
    arg2 = (float) NUM2DBL(argv[0]);
    arg3 = (float) NUM2DBL(argv[1]);
    arg4 = (float) NUM2DBL(argv[2]);
    (arg1)->assign(arg2,arg3,arg4);
    
    return Qnil;
}


static VALUE
_wrap_Color_R(int argc, VALUE *argv, VALUE self) {
    Color *arg1 = (Color *) 0 ;
    float result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Color, 1);
    result = (float)((Color const *)arg1)->R();
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Color_G(int argc, VALUE *argv, VALUE self) {
    Color *arg1 = (Color *) 0 ;
    float result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Color, 1);
    result = (float)((Color const *)arg1)->G();
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Color_B(int argc, VALUE *argv, VALUE self) {
    Color *arg1 = (Color *) 0 ;
    float result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Color, 1);
    result = (float)((Color const *)arg1)->B();
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Color_is_valid(int argc, VALUE *argv, VALUE self) {
    Color *arg1 = (Color *) 0 ;
    bool result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Color, 1);
    result = (bool)((Color const *)arg1)->is_valid();
    
    vresult = result ? Qtrue : Qfalse;
    return vresult;
}


static void
free_Color(Color *arg1) {
    delete arg1;
}
static VALUE
_wrap_default_opengl_color_map(int argc, VALUE *argv, VALUE self) {
    ColorMap *arg1 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_ColorMap, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    default_opengl_color_map(*arg1);
    
    return Qnil;
}


static VALUE
_wrap_default_eps_rgb_map(int argc, VALUE *argv, VALUE self) {
    ColorMap *arg1 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_ColorMap, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    default_eps_rgb_map(*arg1);
    
    return Qnil;
}


static VALUE
_wrap_default_eps_grayscale_map(int argc, VALUE *argv, VALUE self) {
    GrayscaleMap *arg1 = 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_GrayscaleMap, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    default_eps_grayscale_map(*arg1);
    
    return Qnil;
}


static VALUE
_wrap_load_map__SWIG_0(int argc, VALUE *argv, VALUE self) {
    ColorMap *arg1 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_ColorMap, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)load_map(*arg1);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_load_map__SWIG_1(int argc, VALUE *argv, VALUE self) {
    GrayscaleMap *arg1 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_GrayscaleMap, 1); if (arg1 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)load_map(*arg1);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE _wrap_load_map(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[1];
    int ii;
    
    argc = nargs;
    for (ii = 0; (ii < argc) && (ii < 1); ii++) {
        argv[ii] = args[ii];
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_ColorMap, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_load_map__SWIG_0(nargs, args, self);
        }
    }
    if (argc == 1) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_GrayscaleMap, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            return _wrap_load_map__SWIG_1(nargs, args, self);
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'load_map'");
    return Qnil;
}


static VALUE
_wrap_PSCoord_x_set(int argc, VALUE *argv, VALUE self) {
    PSCoord *arg1 = (PSCoord *) 0 ;
    unsigned int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PSCoord, 1);
    arg2 = NUM2UINT(argv[0]);
    if (arg1) (arg1)->x = arg2;
    
    return Qnil;
}


static VALUE
_wrap_PSCoord_x_get(int argc, VALUE *argv, VALUE self) {
    PSCoord *arg1 = (PSCoord *) 0 ;
    unsigned int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PSCoord, 1);
    result = (unsigned int) ((arg1)->x);
    
    vresult = UINT2NUM(result);
    return vresult;
}


static VALUE
_wrap_PSCoord_y_set(int argc, VALUE *argv, VALUE self) {
    PSCoord *arg1 = (PSCoord *) 0 ;
    unsigned int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PSCoord, 1);
    arg2 = NUM2UINT(argv[0]);
    if (arg1) (arg1)->y = arg2;
    
    return Qnil;
}


static VALUE
_wrap_PSCoord_y_get(int argc, VALUE *argv, VALUE self) {
    PSCoord *arg1 = (PSCoord *) 0 ;
    unsigned int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PSCoord, 1);
    result = (unsigned int) ((arg1)->y);
    
    vresult = UINT2NUM(result);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_PSCoord_allocate(VALUE self) {
#else
    static VALUE
    _wrap_PSCoord_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_PSCoord);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_PSCoord(int argc, VALUE *argv, VALUE self) {
    PSCoord *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (PSCoord *)new PSCoord();
    DATA_PTR(self) = result;
    return self;
}


static void
free_PSCoord(PSCoord *arg1) {
    delete arg1;
}
static VALUE
_wrap_PSDrawMode_mode_set(int argc, VALUE *argv, VALUE self) {
    PSDrawMode *arg1 = (PSDrawMode *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PSDrawMode, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->mode = arg2;
    
    return Qnil;
}


static VALUE
_wrap_PSDrawMode_mode_get(int argc, VALUE *argv, VALUE self) {
    PSDrawMode *arg1 = (PSDrawMode *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PSDrawMode, 1);
    result = (int) ((arg1)->mode);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_PSDrawMode_linewidth_set(int argc, VALUE *argv, VALUE self) {
    PSDrawMode *arg1 = (PSDrawMode *) 0 ;
    unsigned int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PSDrawMode, 1);
    arg2 = NUM2UINT(argv[0]);
    if (arg1) (arg1)->linewidth = arg2;
    
    return Qnil;
}


static VALUE
_wrap_PSDrawMode_linewidth_get(int argc, VALUE *argv, VALUE self) {
    PSDrawMode *arg1 = (PSDrawMode *) 0 ;
    unsigned int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PSDrawMode, 1);
    result = (unsigned int) ((arg1)->linewidth);
    
    vresult = UINT2NUM(result);
    return vresult;
}


static VALUE
_wrap_PSDrawMode_grayscale_set(int argc, VALUE *argv, VALUE self) {
    PSDrawMode *arg1 = (PSDrawMode *) 0 ;
    float arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PSDrawMode, 1);
    arg2 = (float) NUM2DBL(argv[0]);
    if (arg1) (arg1)->grayscale = arg2;
    
    return Qnil;
}


static VALUE
_wrap_PSDrawMode_grayscale_get(int argc, VALUE *argv, VALUE self) {
    PSDrawMode *arg1 = (PSDrawMode *) 0 ;
    float result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PSDrawMode, 1);
    result = (float) ((arg1)->grayscale);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_PSDrawMode_rgbcolor_set(int argc, VALUE *argv, VALUE self) {
    PSDrawMode *arg1 = (PSDrawMode *) 0 ;
    Color *arg2 = (Color *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PSDrawMode, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Color, 1);
    if (arg1) (arg1)->rgbcolor = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_PSDrawMode_rgbcolor_get(int argc, VALUE *argv, VALUE self) {
    PSDrawMode *arg1 = (PSDrawMode *) 0 ;
    Color *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_PSDrawMode, 1);
    result = (Color *)& ((arg1)->rgbcolor);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Color,0);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_PSDrawMode_allocate(VALUE self) {
#else
    static VALUE
    _wrap_PSDrawMode_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_PSDrawMode);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_PSDrawMode(int argc, VALUE *argv, VALUE self) {
    PSDrawMode *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (PSDrawMode *)new PSDrawMode();
    DATA_PTR(self) = result;
    return self;
}


static void
free_PSDrawMode(PSDrawMode *arg1) {
    delete arg1;
}
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_EPSWrite_allocate(VALUE self) {
#else
    static VALUE
    _wrap_EPSWrite_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_EPSWrite);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_EPSWrite(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BoundaryMesh *arg2 = (BoundaryMesh *) 0 ;
    EPSWrite *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_BoundaryMesh, 1);
    result = (EPSWrite *)new EPSWrite(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_EPSWrite_load_rgb_map(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    char *arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = StringValuePtr(argv[0]);
    result = (int)(arg1)->load_rgb_map(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EPSWrite_load_grayscale_map(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    char *arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = StringValuePtr(argv[0]);
    result = (int)(arg1)->load_grayscale_map(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EPSWrite_map_rgbcolor(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    int arg2 ;
    Color *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = NUM2INT(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->map_rgbcolor(arg2,(Color const &)*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EPSWrite_map_grayscale(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    int arg2 ;
    float arg3 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = NUM2INT(argv[0]);
    arg3 = (float) NUM2DBL(argv[1]);
    result = (int)(arg1)->map_grayscale(arg2,arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EPSWrite_set_border_draw(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    int arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = NUM2INT(argv[0]);
    result = (int)(arg1)->set_border_draw(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EPSWrite_set_border_ink__SWIG_0(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    unsigned int arg2 ;
    float arg3 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = NUM2UINT(argv[0]);
    arg3 = (float) NUM2DBL(argv[1]);
    result = (int)(arg1)->set_border_ink(arg2,arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EPSWrite_set_border_ink__SWIG_1(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    unsigned int arg2 ;
    Color *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = NUM2UINT(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->set_border_ink(arg2,(Color const &)*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE _wrap_EPSWrite_set_border_ink(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_EPSWrite, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_EPSWrite_set_border_ink__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_EPSWrite, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FLOAT) || (TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_EPSWrite_set_border_ink__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'EPSWrite_set_border_ink'");
    return Qnil;
}


static VALUE
_wrap_EPSWrite_set_edge_draw(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    int arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = NUM2INT(argv[0]);
    result = (int)(arg1)->set_edge_draw(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EPSWrite_set_edge_ink__SWIG_0(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    unsigned int arg2 ;
    float arg3 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = NUM2UINT(argv[0]);
    arg3 = (float) NUM2DBL(argv[1]);
    result = (int)(arg1)->set_edge_ink(arg2,arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EPSWrite_set_edge_ink__SWIG_1(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    unsigned int arg2 ;
    Color *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = NUM2UINT(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->set_edge_ink(arg2,(Color const &)*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE _wrap_EPSWrite_set_edge_ink(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_EPSWrite, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_EPSWrite_set_edge_ink__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_EPSWrite, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FLOAT) || (TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_EPSWrite_set_edge_ink__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'EPSWrite_set_edge_ink'");
    return Qnil;
}


static VALUE
_wrap_EPSWrite_set_bdry_draw(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    int arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = NUM2INT(argv[0]);
    result = (int)(arg1)->set_bdry_draw(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EPSWrite_set_bdry_ink__SWIG_0(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    unsigned int arg2 ;
    float arg3 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = NUM2UINT(argv[0]);
    arg3 = (float) NUM2DBL(argv[1]);
    result = (int)(arg1)->set_bdry_ink(arg2,arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EPSWrite_set_bdry_ink__SWIG_1(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    unsigned int arg2 ;
    Color *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = NUM2UINT(argv[0]);
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Color, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->set_bdry_ink(arg2,(Color const &)*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE _wrap_EPSWrite_set_bdry_ink(int nargs, VALUE *args, VALUE self) {
    int argc;
    VALUE argv[4];
    int ii;
    
    argc = nargs + 1;
    argv[0] = self;
    for (ii = 1; (ii < argc) && (ii < 3); ii++) {
        argv[ii] = args[ii-1];
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_EPSWrite, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    void *ptr;
                    _v = (NIL_P(argv[2]) || (TYPE(argv[2]) == T_DATA && SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_Color, 0) != -1)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_EPSWrite_set_bdry_ink__SWIG_1(nargs, args, self);
                }
            }
        }
    }
    if (argc == 3) {
        int _v;
        {
            void *ptr;
            _v = (NIL_P(argv[0]) || (TYPE(argv[0]) == T_DATA && SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_EPSWrite, 0) != -1)) ? 1 : 0;
        }
        if (_v) {
            {
                _v = ((TYPE(argv[1]) == T_FIXNUM) || (TYPE(argv[1]) == T_BIGNUM)) ? 1 : 0;
            }
            if (_v) {
                {
                    _v = ((TYPE(argv[2]) == T_FLOAT) || (TYPE(argv[2]) == T_FIXNUM) || (TYPE(argv[2]) == T_BIGNUM)) ? 1 : 0;
                }
                if (_v) {
                    return _wrap_EPSWrite_set_bdry_ink__SWIG_0(nargs, args, self);
                }
            }
        }
    }
    
    rb_raise(rb_eArgError, "No matching function for overloaded 'EPSWrite_set_bdry_ink'");
    return Qnil;
}


static VALUE
_wrap_EPSWrite_set_face_draw(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    int arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = NUM2INT(argv[0]);
    result = (int)(arg1)->set_face_draw(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EPSWrite_set_page_dim(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    unsigned int arg2 ;
    unsigned int arg3 ;
    unsigned int arg4 ;
    unsigned int arg5 ;
    unsigned int arg6 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 5) || (argc > 5))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = NUM2UINT(argv[0]);
    arg3 = NUM2UINT(argv[1]);
    arg4 = NUM2UINT(argv[2]);
    arg5 = NUM2UINT(argv[3]);
    arg6 = NUM2UINT(argv[4]);
    result = (int)(arg1)->set_page_dim(arg2,arg3,arg4,arg5,arg6);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EPSWrite_set_page_dim_inch(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    float arg2 ;
    float arg3 ;
    float arg4 ;
    float arg5 ;
    float arg6 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 5) || (argc > 5))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = (float) NUM2DBL(argv[0]);
    arg3 = (float) NUM2DBL(argv[1]);
    arg4 = (float) NUM2DBL(argv[2]);
    arg5 = (float) NUM2DBL(argv[3]);
    arg6 = (float) NUM2DBL(argv[4]);
    result = (int)(arg1)->set_page_dim_inch(arg2,arg3,arg4,arg5,arg6);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EPSWrite_set_world_view(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    Point2D *arg2 = 0 ;
    Point2D *arg3 = 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1); if (arg2 == NULL) rb_raise(rb_eTypeError, "null reference");
    SWIG_ConvertPtr(argv[1], (void **) &arg3, SWIGTYPE_p_Point2D, 1); if (arg3 == NULL) rb_raise(rb_eTypeError, "null reference");
    result = (int)(arg1)->set_world_view((Point2D const &)*arg2,(Point2D const &)*arg3);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_EPSWrite_write(int argc, VALUE *argv, VALUE self) {
    EPSWrite *arg1 = (EPSWrite *) 0 ;
    char *arg2 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_EPSWrite, 1);
    arg2 = StringValuePtr(argv[0]);
    result = (int)(arg1)->write(arg2);
    
    vresult = INT2NUM(result);
    return vresult;
}


static void
free_EPSWrite(EPSWrite *arg1) {
    delete arg1;
}
#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_MeshConstructor_allocate(VALUE self) {
#else
    static VALUE
    _wrap_MeshConstructor_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_MeshConstructor);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_MeshConstructor(int argc, VALUE *argv, VALUE self) {
    BezierMesh *arg1 = (BezierMesh *) 0 ;
    BoundaryMesh *arg2 = (BoundaryMesh *) 0 ;
    MeshConstructor *result;
    
    if ((argc < 2) || (argc > 2))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc);
    SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_BezierMesh, 1);
    SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_BoundaryMesh, 1);
    result = (MeshConstructor *)new MeshConstructor(arg1,arg2);
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_MeshConstructor_make_simulation(int argc, VALUE *argv, VALUE self) {
    MeshConstructor *arg1 = (MeshConstructor *) 0 ;
    Simulation *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_MeshConstructor, 1);
    result = (Simulation *)(arg1)->make_simulation();
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Simulation,0);
    return vresult;
}


static void
free_MeshConstructor(MeshConstructor *arg1) {
    delete arg1;
}
static VALUE
_wrap_Pump_outer_edges_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    vector<BoundaryEdge * > *arg2 = (vector<BoundaryEdge * > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTBoundaryEdge_p_t, 1);
    if (arg1) (arg1)->outer_edges = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_outer_edges_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    vector<BoundaryEdge * > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (vector<BoundaryEdge * > *)& ((arg1)->outer_edges);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTBoundaryEdge_p_t,0);
    return vresult;
}


static VALUE
_wrap_Pump_propeller_edges_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    vector<BoundaryEdge * > *arg2 = (vector<BoundaryEdge * > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTBoundaryEdge_p_t, 1);
    if (arg1) (arg1)->propeller_edges = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_propeller_edges_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    vector<BoundaryEdge * > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (vector<BoundaryEdge * > *)& ((arg1)->propeller_edges);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTBoundaryEdge_p_t,0);
    return vresult;
}


static VALUE
_wrap_Pump_inlet_edges_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    vector<BoundaryEdge * > *arg2 = (vector<BoundaryEdge * > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTBoundaryEdge_p_t, 1);
    if (arg1) (arg1)->inlet_edges = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_inlet_edges_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    vector<BoundaryEdge * > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (vector<BoundaryEdge * > *)& ((arg1)->inlet_edges);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTBoundaryEdge_p_t,0);
    return vresult;
}


static VALUE
_wrap_Pump_outlet_edge_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    if (arg1) (arg1)->outlet_edge = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_outlet_edge_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    BoundaryEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (BoundaryEdge *) ((arg1)->outlet_edge);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryEdge,0);
    return vresult;
}


static VALUE
_wrap_Pump_pump_face_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    if (arg1) (arg1)->pump_face = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_pump_face_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    BoundaryFace *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (BoundaryFace *) ((arg1)->pump_face);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryFace,0);
    return vresult;
}


static VALUE
_wrap_Pump_cell_edges_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    vector<BoundaryEdge * > *arg2 = (vector<BoundaryEdge * > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTBoundaryEdge_p_t, 1);
    if (arg1) (arg1)->cell_edges = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_cell_edges_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    vector<BoundaryEdge * > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (vector<BoundaryEdge * > *)& ((arg1)->cell_edges);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTBoundaryEdge_p_t,0);
    return vresult;
}


static VALUE
_wrap_Pump_cell_centers_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    vector<Point2D > *arg2 = (vector<Point2D > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTPoint2D_t, 1);
    if (arg1) (arg1)->cell_centers = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_cell_centers_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    vector<Point2D > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (vector<Point2D > *)& ((arg1)->cell_centers);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTPoint2D_t,0);
    return vresult;
}


static VALUE
_wrap_Pump_cell_faces_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    vector<BoundaryFace * > *arg2 = (vector<BoundaryFace * > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTBoundaryFace_p_t, 1);
    if (arg1) (arg1)->cell_faces = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_cell_faces_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    vector<BoundaryFace * > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (vector<BoundaryFace * > *)& ((arg1)->cell_faces);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTBoundaryFace_p_t,0);
    return vresult;
}


static VALUE
_wrap_Pump_center_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Point2D *arg2 = (Point2D *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_Point2D, 1);
    if (arg1) (arg1)->center = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_center_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Point2D *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (Point2D *)& ((arg1)->center);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_Point2D,0);
    return vresult;
}


static VALUE
_wrap_Pump_inlet_radius_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Micron arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    arg2 = (Micron) NUM2DBL(argv[0]);
    if (arg1) (arg1)->inlet_radius = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_inlet_radius_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Micron result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (Micron) ((arg1)->inlet_radius);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Pump_outer_radius_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Micron arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    arg2 = (Micron) NUM2DBL(argv[0]);
    if (arg1) (arg1)->outer_radius = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_outer_radius_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Micron result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (Micron) ((arg1)->outer_radius);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Pump_outlet_width_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Micron arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    arg2 = (Micron) NUM2DBL(argv[0]);
    if (arg1) (arg1)->outlet_width = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_outlet_width_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Micron result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (Micron) ((arg1)->outlet_width);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Pump_outlet_length_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Micron arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    arg2 = (Micron) NUM2DBL(argv[0]);
    if (arg1) (arg1)->outlet_length = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_outlet_length_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Micron result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (Micron) ((arg1)->outlet_length);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Pump_num_blades_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->num_blades = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_num_blades_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (int) ((arg1)->num_blades);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Pump_blade_width_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Radians arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    arg2 = (Radians) NUM2DBL(argv[0]);
    if (arg1) (arg1)->blade_width = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_blade_width_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Radians result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (Radians) ((arg1)->blade_width);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Pump_blade_gap_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Micron arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    arg2 = (Micron) NUM2DBL(argv[0]);
    if (arg1) (arg1)->blade_gap = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_blade_gap_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Micron result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (Micron) ((arg1)->blade_gap);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Pump_velocity_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Radians arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    arg2 = (Radians) NUM2DBL(argv[0]);
    if (arg1) (arg1)->velocity = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_velocity_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Radians result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (Radians) ((arg1)->velocity);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Pump_num_cells_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->num_cells = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_num_cells_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (int) ((arg1)->num_cells);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Pump_cell_type_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->cell_type = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_cell_type_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (int) ((arg1)->cell_type);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_Pump_cell_width_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Micron arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    arg2 = (Micron) NUM2DBL(argv[0]);
    if (arg1) (arg1)->cell_width = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_cell_width_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Micron result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (Micron) ((arg1)->cell_width);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Pump_cell_height_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Micron arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    arg2 = (Micron) NUM2DBL(argv[0]);
    if (arg1) (arg1)->cell_height = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_cell_height_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    Micron result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (Micron) ((arg1)->cell_height);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Pump_size_const_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->size_const = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_size_const_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (double) ((arg1)->size_const);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_Pump_min_angle_set(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->min_angle = arg2;
    
    return Qnil;
}


static VALUE
_wrap_Pump_min_angle_get(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (double) ((arg1)->min_angle);
    
    vresult = rb_float_new(result);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_Pump_allocate(VALUE self) {
#else
    static VALUE
    _wrap_Pump_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Pump);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_Pump(int argc, VALUE *argv, VALUE self) {
    Pump *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (Pump *)new Pump();
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_Pump_make_test(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    (arg1)->make_test();
    
    return Qnil;
}


static VALUE
_wrap_Pump_make_pump(int argc, VALUE *argv, VALUE self) {
    Pump *arg1 = (Pump *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_Pump, 1);
    result = (int)(arg1)->make_pump();
    
    vresult = INT2NUM(result);
    return vresult;
}


static void
free_Pump(Pump *arg1) {
    delete arg1;
}
static VALUE
_wrap_SlitCavity_outer_edges_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    vector<BoundaryEdge * > *arg2 = (vector<BoundaryEdge * > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTBoundaryEdge_p_t, 1);
    if (arg1) (arg1)->outer_edges = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_outer_edges_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    vector<BoundaryEdge * > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (vector<BoundaryEdge * > *)& ((arg1)->outer_edges);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTBoundaryEdge_p_t,0);
    return vresult;
}


static VALUE
_wrap_SlitCavity_rear_edge_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    if (arg1) (arg1)->rear_edge = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_rear_edge_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    BoundaryEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (BoundaryEdge *) ((arg1)->rear_edge);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryEdge,0);
    return vresult;
}


static VALUE
_wrap_SlitCavity_forward_edge_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    BoundaryEdge *arg2 = (BoundaryEdge *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryEdge, 1);
    if (arg1) (arg1)->forward_edge = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_forward_edge_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    BoundaryEdge *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (BoundaryEdge *) ((arg1)->forward_edge);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryEdge,0);
    return vresult;
}


static VALUE
_wrap_SlitCavity_cell_edges_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    vector<BoundaryEdge * > *arg2 = (vector<BoundaryEdge * > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTBoundaryEdge_p_t, 1);
    if (arg1) (arg1)->cell_edges = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_cell_edges_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    vector<BoundaryEdge * > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (vector<BoundaryEdge * > *)& ((arg1)->cell_edges);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTBoundaryEdge_p_t,0);
    return vresult;
}


static VALUE
_wrap_SlitCavity_cell_centers_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    vector<Point2D > *arg2 = (vector<Point2D > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTPoint2D_t, 1);
    if (arg1) (arg1)->cell_centers = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_cell_centers_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    vector<Point2D > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (vector<Point2D > *)& ((arg1)->cell_centers);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTPoint2D_t,0);
    return vresult;
}


static VALUE
_wrap_SlitCavity_cell_faces_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    vector<BoundaryFace * > *arg2 = (vector<BoundaryFace * > *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_vectorTBoundaryFace_p_t, 1);
    if (arg1) (arg1)->cell_faces = *arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_cell_faces_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    vector<BoundaryFace * > *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (vector<BoundaryFace * > *)& ((arg1)->cell_faces);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_vectorTBoundaryFace_p_t,0);
    return vresult;
}


static VALUE
_wrap_SlitCavity_cavity_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    BoundaryFace *arg2 = (BoundaryFace *) 0 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    SWIG_ConvertPtr(argv[0], (void **) &arg2, SWIGTYPE_p_BoundaryFace, 1);
    if (arg1) (arg1)->cavity = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_cavity_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    BoundaryFace *result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (BoundaryFace *) ((arg1)->cavity);
    
    vresult = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_BoundaryFace,0);
    return vresult;
}


static VALUE
_wrap_SlitCavity_min_angle_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Degrees arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    arg2 = (Degrees) NUM2DBL(argv[0]);
    if (arg1) (arg1)->min_angle = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_min_angle_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Degrees result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (Degrees) ((arg1)->min_angle);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_SlitCavity_num_cells_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->num_cells = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_num_cells_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (int) ((arg1)->num_cells);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_SlitCavity_cell_type_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    int arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    arg2 = NUM2INT(argv[0]);
    if (arg1) (arg1)->cell_type = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_cell_type_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (int) ((arg1)->cell_type);
    
    vresult = INT2NUM(result);
    return vresult;
}


static VALUE
_wrap_SlitCavity_cell_width_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Micron arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    arg2 = (Micron) NUM2DBL(argv[0]);
    if (arg1) (arg1)->cell_width = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_cell_width_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Micron result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (Micron) ((arg1)->cell_width);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_SlitCavity_cell_height_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Micron arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    arg2 = (Micron) NUM2DBL(argv[0]);
    if (arg1) (arg1)->cell_height = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_cell_height_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Micron result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (Micron) ((arg1)->cell_height);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_SlitCavity_slit_height_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Micron arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    arg2 = (Micron) NUM2DBL(argv[0]);
    if (arg1) (arg1)->slit_height = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_slit_height_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Micron result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (Micron) ((arg1)->slit_height);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_SlitCavity_slit_length_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Micron arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    arg2 = (Micron) NUM2DBL(argv[0]);
    if (arg1) (arg1)->slit_length = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_slit_length_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Micron result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (Micron) ((arg1)->slit_length);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_SlitCavity_cavity_height_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Micron arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    arg2 = (Micron) NUM2DBL(argv[0]);
    if (arg1) (arg1)->cavity_height = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_cavity_height_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Micron result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (Micron) ((arg1)->cavity_height);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_SlitCavity_inlet_length_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Micron arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    arg2 = (Micron) NUM2DBL(argv[0]);
    if (arg1) (arg1)->inlet_length = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_inlet_length_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Micron result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (Micron) ((arg1)->inlet_length);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_SlitCavity_outlet_length_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Micron arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    arg2 = (Micron) NUM2DBL(argv[0]);
    if (arg1) (arg1)->outlet_length = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_outlet_length_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Micron result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (Micron) ((arg1)->outlet_length);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_SlitCavity_taper_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Radians arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    arg2 = (Radians) NUM2DBL(argv[0]);
    if (arg1) (arg1)->taper = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_taper_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    Radians result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (Radians) ((arg1)->taper);
    
    vresult = rb_float_new(result);
    return vresult;
}


static VALUE
_wrap_SlitCavity_size_const_set(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    double arg2 ;
    
    if ((argc < 1) || (argc > 1))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    arg2 = (double) NUM2DBL(argv[0]);
    if (arg1) (arg1)->size_const = arg2;
    
    return Qnil;
}


static VALUE
_wrap_SlitCavity_size_const_get(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    double result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (double) ((arg1)->size_const);
    
    vresult = rb_float_new(result);
    return vresult;
}


#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
static VALUE
_wrap_SlitCavity_allocate(VALUE self) {
#else
    static VALUE
    _wrap_SlitCavity_allocate(int argc, VALUE *argv, VALUE self) {
#endif
        
        
        VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_SlitCavity);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
        rb_obj_call_init(vresult, argc, argv);
#endif
        return vresult;
    }
    

static VALUE
_wrap_new_SlitCavity(int argc, VALUE *argv, VALUE self) {
    SlitCavity *result;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    result = (SlitCavity *)new SlitCavity();
    DATA_PTR(self) = result;
    return self;
}


static VALUE
_wrap_SlitCavity_make_cavity(int argc, VALUE *argv, VALUE self) {
    SlitCavity *arg1 = (SlitCavity *) 0 ;
    int result;
    VALUE vresult = Qnil;
    
    if ((argc < 0) || (argc > 0))
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc);
    SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_SlitCavity, 1);
    result = (int)(arg1)->make_cavity();
    
    vresult = INT2NUM(result);
    return vresult;
}


static void
free_SlitCavity(SlitCavity *arg1) {
    delete arg1;
}

/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_BoundaryEdgeTo_p_Cell(void *x) {
    return (void *)((Cell *) (EdgeCell *) ((BoundaryEdge *) x));
}
static void *_p_BoundaryFaceTo_p_Cell(void *x) {
    return (void *)((Cell *) (FaceCell *) ((BoundaryFace *) x));
}
static void *_p_FaceCellTo_p_Cell(void *x) {
    return (void *)((Cell *)  ((FaceCell *) x));
}
static void *_p_BezierVertexTo_p_Cell(void *x) {
    return (void *)((Cell *) (VertexCell *) ((BezierVertex *) x));
}
static void *_p_BezierEdgeTo_p_Cell(void *x) {
    return (void *)((Cell *) (EdgeCell *) ((BezierEdge *) x));
}
static void *_p_EdgeCellTo_p_Cell(void *x) {
    return (void *)((Cell *)  ((EdgeCell *) x));
}
static void *_p_BoundaryVertexTo_p_Cell(void *x) {
    return (void *)((Cell *) (VertexCell *) ((BoundaryVertex *) x));
}
static void *_p_BezierTriangleTo_p_Cell(void *x) {
    return (void *)((Cell *) (FaceCell *) ((BezierTriangle *) x));
}
static void *_p_VertexCellTo_p_Cell(void *x) {
    return (void *)((Cell *)  ((VertexCell *) x));
}
static void *_p_PumpTo_p_Simulation(void *x) {
    return (void *)((Simulation *)  ((Pump *) x));
}
static void *_p_SlitCavityTo_p_Simulation(void *x) {
    return (void *)((Simulation *)  ((SlitCavity *) x));
}
static void *_p_BoundaryFaceTo_p_FaceCell(void *x) {
    return (void *)((FaceCell *)  ((BoundaryFace *) x));
}
static void *_p_BezierTriangleTo_p_FaceCell(void *x) {
    return (void *)((FaceCell *)  ((BezierTriangle *) x));
}
static void *_p_PumpTo_p_MeshConstructor(void *x) {
    return (void *)((MeshConstructor *)  ((Pump *) x));
}
static void *_p_SlitCavityTo_p_MeshConstructor(void *x) {
    return (void *)((MeshConstructor *)  ((SlitCavity *) x));
}
static void *_p_BezierMeshTo_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t(void *x) {
    return (void *)((CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > > *)  ((BezierMesh *) x));
}
static void *_p_BezierVertexTo_p_VertexCell(void *x) {
    return (void *)((VertexCell *)  ((BezierVertex *) x));
}
static void *_p_BoundaryVertexTo_p_VertexCell(void *x) {
    return (void *)((VertexCell *)  ((BoundaryVertex *) x));
}
static void *_p_BoundaryEdgeTo_p_EdgeCell(void *x) {
    return (void *)((EdgeCell *)  ((BoundaryEdge *) x));
}
static void *_p_BezierEdgeTo_p_EdgeCell(void *x) {
    return (void *)((EdgeCell *)  ((BezierEdge *) x));
}
static void *_p_BoundaryMeshTo_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t(void *x) {
    return (void *)((CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > > *)  ((BoundaryMesh *) x));
}
static void *_p_BezierTriangleTo_p_CurvedTriangle(void *x) {
    return (void *)((CurvedTriangle *)  ((BezierTriangle *) x));
}
static void *_p_GhostTriangleTo_p_CurvedTriangle(void *x) {
    return (void *)((CurvedTriangle *)  ((GhostTriangle *) x));
}
static swig_type_info _swigt__p_GrayscaleMap[] = {{"_p_GrayscaleMap", 0, "GrayscaleMap *", 0},{"_p_GrayscaleMap"},{0}};
static swig_type_info _swigt__p_Cell[] = {{"_p_Cell", 0, "Cell *", 0},{"_p_BoundaryEdge", _p_BoundaryEdgeTo_p_Cell},{"_p_BoundaryFace", _p_BoundaryFaceTo_p_Cell},{"_p_FaceCell", _p_FaceCellTo_p_Cell},{"_p_BezierVertex", _p_BezierVertexTo_p_Cell},{"_p_BezierEdge", _p_BezierEdgeTo_p_Cell},{"_p_Cell"},{"_p_BezierTriangle", _p_BezierTriangleTo_p_Cell},{"_p_EdgeCell", _p_EdgeCellTo_p_Cell},{"_p_BoundaryVertex", _p_BoundaryVertexTo_p_Cell},{"_p_VertexCell", _p_VertexCellTo_p_Cell},{0}};
static swig_type_info _swigt__p_ControlPoint[] = {{"_p_ControlPoint", 0, "ControlPoint *", 0},{"_p_ControlPoint"},{0}};
static swig_type_info _swigt__p_hash_setTBoundaryFace_p_CellHasherTBoundaryFace_t_CellEqualTBoundaryFace_t_t[] = {{"_p_hash_setTBoundaryFace_p_CellHasherTBoundaryFace_t_CellEqualTBoundaryFace_t_t", 0, "CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Face_Hash_T *", 0},{"_p_hash_setTBoundaryFace_p_CellHasherTBoundaryFace_t_CellEqualTBoundaryFace_t_t"},{0}};
static swig_type_info _swigt__p_BoundaryFace[] = {{"_p_BoundaryFace", 0, "BoundaryFace *", 0},{"_p_BoundaryFace"},{0}};
static swig_type_info _swigt__p_Color[] = {{"_p_Color", 0, "Color *", 0},{"_p_Color"},{0}};
static swig_type_info _swigt__p_Pump[] = {{"_p_Pump", 0, "Pump *", 0},{"_p_Pump"},{0}};
static swig_type_info _swigt__p_hash_mapTlistTPoint2D_t__iterator_listTLinearData_t__iterator_ControlPointHasher_ControlPointEqual_t[] = {{"_p_hash_mapTlistTPoint2D_t__iterator_listTLinearData_t__iterator_ControlPointHasher_ControlPointEqual_t", 0, "CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Data_Hash_T *", 0},{"_p_hash_mapTlistTPoint2D_t__iterator_listTLinearData_t__iterator_ControlPointHasher_ControlPointEqual_t"},{0}};
static swig_type_info _swigt__p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t[] = {{"_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t", 0, "CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > *", 0},{"_p_BoundaryTuple"},{"_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t"},{0}};
static swig_type_info _swigt__p_SlitCavity[] = {{"_p_SlitCavity", 0, "SlitCavity *", 0},{"_p_SlitCavity"},{0}};
static swig_type_info _swigt__p_hash_setTBezierEdge_p_CellHasherTBezierEdge_t_CellEqualTBezierEdge_t_t[] = {{"_p_hash_setTBezierEdge_p_CellHasherTBezierEdge_t_CellEqualTBezierEdge_t_t", 0, "CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Edge_Hash_T *", 0},{"_p_hash_setTBezierEdge_p_CellHasherTBezierEdge_t_CellEqualTBezierEdge_t_t"},{0}};
static swig_type_info _swigt__p_BezierVertex[] = {{"_p_BezierVertex", 0, "BezierVertex *", 0},{"_p_BezierVertex"},{0}};
static swig_type_info _swigt__p_hash_setTBezierVertex_p_CellHasherTBezierVertex_t_CellEqualTBezierVertex_t_t[] = {{"_p_hash_setTBezierVertex_p_CellHasherTBezierVertex_t_CellEqualTBezierVertex_t_t", 0, "CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Vertex_Hash_T *", 0},{"_p_hash_setTBezierVertex_p_CellHasherTBezierVertex_t_CellEqualTBezierVertex_t_t"},{0}};
static swig_type_info _swigt__p_Simulation[] = {{"_p_Simulation", 0, "Simulation *", 0},{"_p_Pump", _p_PumpTo_p_Simulation},{"_p_Simulation"},{"_p_SlitCavity", _p_SlitCavityTo_p_Simulation},{0}};
static swig_type_info _swigt__p_Visualization[] = {{"_p_Visualization", 0, "Visualization *", 0},{"_p_Visualization"},{0}};
static swig_type_info _swigt__p_PSCoord[] = {{"_p_PSCoord", 0, "PSCoord *", 0},{"_p_PSCoord"},{0}};
static swig_type_info _swigt__p_vectorTlistTPoint2D_t__iterator_t[] = {{"_p_vectorTlistTPoint2D_t__iterator_t", 0, "vector<ControlPoint > const *", 0},{"_p_vectorTlistTPoint2D_t__iterator_t"},{0}};
static swig_type_info _swigt__p_hash_setTBoundaryVertex_p_CellHasherTBoundaryVertex_t_CellEqualTBoundaryVertex_t_t[] = {{"_p_hash_setTBoundaryVertex_p_CellHasherTBoundaryVertex_t_CellEqualTBoundaryVertex_t_t", 0, "CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Vertex_Hash_T *", 0},{"_p_hash_setTBoundaryVertex_p_CellHasherTBoundaryVertex_t_CellEqualTBoundaryVertex_t_t"},{0}};
static swig_type_info _swigt__p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t[] = {{"_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t", 0, "CellTuple<BezierVertex,BezierEdge,BezierTriangle > *", 0},{"_p_BezierTuple"},{"_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t"},{0}};
static swig_type_info _swigt__p_FaceCell[] = {{"_p_FaceCell", 0, "FaceCell *", 0},{"_p_BoundaryFace", _p_BoundaryFaceTo_p_FaceCell},{"_p_FaceCell"},{"_p_BezierTriangle", _p_BezierTriangleTo_p_FaceCell},{0}};
static swig_type_info _swigt__p_MeshConstructor[] = {{"_p_MeshConstructor", 0, "MeshConstructor *", 0},{"_p_Pump", _p_PumpTo_p_MeshConstructor},{"_p_MeshConstructor"},{"_p_SlitCavity", _p_SlitCavityTo_p_MeshConstructor},{0}};
static swig_type_info _swigt__p_Point2D[] = {{"_p_Point2D", 0, "Point2D *", 0},{"_p_Point2D"},{0}};
static swig_type_info _swigt__p_p_void[] = {{"_p_p_void", 0, "void **", 0},{"_p_p_void"},{0}};
static swig_type_info _swigt__p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t[] = {{"_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t", 0, "CellComplex<BezierVertex,BezierEdge,BezierTriangle,BezierTuple > *", 0},{"_p_BezierMesh", _p_BezierMeshTo_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t},{"_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t"},{0}};
static swig_type_info _swigt__p_double[] = {{"_p_double", 0, "double *", 0},{"_p_double"},{0}};
static swig_type_info _swigt__p_p_double[] = {{"_p_p_double", 0, "double **", 0},{"_p_p_double"},{0}};
static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0},{"_p_int"},{0}};
static swig_type_info _swigt__p_MeshInput[] = {{"_p_MeshInput", 0, "MeshInput *", 0},{"_p_MeshInput"},{0}};
static swig_type_info _swigt__p_VertexCell[] = {{"_p_VertexCell", 0, "VertexCell *", 0},{"_p_BezierVertex", _p_BezierVertexTo_p_VertexCell},{"_p_BoundaryVertex", _p_BoundaryVertexTo_p_VertexCell},{"_p_VertexCell"},{0}};
static swig_type_info _swigt__p_dequeTBezierTriangle_p_t[] = {{"_p_dequeTBezierTriangle_p_t", 0, "deque<BezierTriangle * > *", 0},{"_p_dequeTBezierTriangle_p_t"},{0}};
static swig_type_info _swigt__p_listTBezierTriangle_p_t[] = {{"_p_listTBezierTriangle_p_t", 0, "list<BezierTriangle * > *", 0},{"_p_listTBezierTriangle_p_t"},{0}};
static swig_type_info _swigt__p_vectorTBezierTriangle_p_t[] = {{"_p_vectorTBezierTriangle_p_t", 0, "vector<BezierTriangle * > *", 0},{"_p_vectorTBezierTriangle_p_t"},{0}};
static swig_type_info _swigt__p_LinearData[] = {{"_p_LinearData", 0, "LinearData *", 0},{"_p_LinearData"},{0}};
static swig_type_info _swigt__p_EdgeCell[] = {{"_p_EdgeCell", 0, "EdgeCell *", 0},{"_p_BoundaryEdge", _p_BoundaryEdgeTo_p_EdgeCell},{"_p_BezierEdge", _p_BezierEdgeTo_p_EdgeCell},{"_p_EdgeCell"},{0}};
static swig_type_info _swigt__p_p_BezierEdge[] = {{"_p_p_BezierEdge", 0, "BezierEdge **", 0},{"_p_p_BezierEdge"},{0}};
static swig_type_info _swigt__p_BezierEdge[] = {{"_p_BezierEdge", 0, "BezierEdge *", 0},{"_p_BezierEdge"},{0}};
static swig_type_info _swigt__p_DataPoint[] = {{"_p_DataPoint", 0, "DataPoint *", 0},{"_p_DataPoint"},{0}};
static swig_type_info _swigt__p_hash_setTBezierTriangle_p_CellHasherTBezierTriangle_t_CellEqualTBezierTriangle_t_t[] = {{"_p_hash_setTBezierTriangle_p_CellHasherTBezierTriangle_t_CellEqualTBezierTriangle_t_t", 0, "CellComplex<BezierVertex,BezierEdge,BezierTriangle,CellTuple<BezierVertex,BezierEdge,BezierTriangle > >::Face_Hash_T *", 0},{"_p_hash_setTBezierTriangle_p_CellHasherTBezierTriangle_t_CellEqualTBezierTriangle_t_t"},{0}};
static swig_type_info _swigt__p_vectorTdouble_t[] = {{"_p_vectorTdouble_t", 0, "vector<double > *", 0},{"_p_vectorTdouble_t"},{0}};
static swig_type_info _swigt__p_Matrix5[] = {{"_p_Matrix5", 0, "Matrix5 *", 0},{"_p_Matrix5"},{0}};
static swig_type_info _swigt__p_TimeKeeper[] = {{"_p_TimeKeeper", 0, "TimeKeeper *", 0},{"_p_TimeKeeper"},{0}};
static swig_type_info _swigt__p_QBSpline[] = {{"_p_QBSpline", 0, "QBSpline *", 0},{"_p_QBSpline"},{0}};
static swig_type_info _swigt__p_ColorMap[] = {{"_p_ColorMap", 0, "ColorMap *", 0},{"_p_ColorMap"},{0}};
static swig_type_info _swigt__p_MeshOutput[] = {{"_p_MeshOutput", 0, "MeshOutput *", 0},{"_p_MeshOutput"},{0}};
static swig_type_info _swigt__p_dequeTBoundaryFace_p_t[] = {{"_p_dequeTBoundaryFace_p_t", 0, "deque<BoundaryFace * > *", 0},{"_p_dequeTBoundaryFace_p_t"},{0}};
static swig_type_info _swigt__p_listTBoundaryFace_p_t[] = {{"_p_listTBoundaryFace_p_t", 0, "list<BoundaryFace * > *", 0},{"_p_listTBoundaryFace_p_t"},{0}};
static swig_type_info _swigt__p_vectorTBoundaryFace_p_t[] = {{"_p_vectorTBoundaryFace_p_t", 0, "vector<BoundaryFace * > *", 0},{"_p_vectorTBoundaryFace_p_t"},{0}};
static swig_type_info _swigt__p_BezierMesh[] = {{"_p_BezierMesh", 0, "BezierMesh *", 0},{"_p_BezierMesh"},{0}};
static swig_type_info _swigt__p_hash_setTBoundaryEdge_p_CellHasherTBoundaryEdge_t_CellEqualTBoundaryEdge_t_t[] = {{"_p_hash_setTBoundaryEdge_p_CellHasherTBoundaryEdge_t_CellEqualTBoundaryEdge_t_t", 0, "CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,CellTuple<BoundaryVertex,BoundaryEdge,BoundaryFace > >::Edge_Hash_T *", 0},{"_p_hash_setTBoundaryEdge_p_CellHasherTBoundaryEdge_t_CellEqualTBoundaryEdge_t_t"},{0}};
static swig_type_info _swigt__p_p_BoundaryEdge[] = {{"_p_p_BoundaryEdge", 0, "BoundaryEdge **", 0},{"_p_p_BoundaryEdge"},{0}};
static swig_type_info _swigt__p_BoundaryEdge[] = {{"_p_BoundaryEdge", 0, "BoundaryEdge *", 0},{"_p_BoundaryEdge"},{0}};
static swig_type_info _swigt__p_BezierTuple[] = {{"_p_BezierTuple", 0, "BezierTuple *", 0},{"_p_BezierTuple"},{"_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t"},{0}};
static swig_type_info _swigt__p_listTBoundaryVertex_p_t[] = {{"_p_listTBoundaryVertex_p_t", 0, "list<BoundaryVertex * > *", 0},{"_p_listTBoundaryVertex_p_t"},{0}};
static swig_type_info _swigt__p_vectorTBoundaryVertex_p_t[] = {{"_p_vectorTBoundaryVertex_p_t", 0, "vector<BoundaryVertex * > *", 0},{"_p_vectorTBoundaryVertex_p_t"},{0}};
static swig_type_info _swigt__p_listTBezierVertex_p_t[] = {{"_p_listTBezierVertex_p_t", 0, "list<BezierVertex * > *", 0},{"_p_listTBezierVertex_p_t"},{0}};
static swig_type_info _swigt__p_vectorTBezierVertex_p_t[] = {{"_p_vectorTBezierVertex_p_t", 0, "vector<BezierVertex * > *", 0},{"_p_vectorTBezierVertex_p_t"},{0}};
static swig_type_info _swigt__p_vectorTPoint2D_t[] = {{"_p_vectorTPoint2D_t", 0, "vector<Point2D > *", 0},{"_p_vectorTPoint2D_t"},{0}};
static swig_type_info _swigt__p_listTPoint2D_t[] = {{"_p_listTPoint2D_t", 0, "list<Point2D > *", 0},{"_p_listTPoint2D_t"},{0}};
static swig_type_info _swigt__p_BoundaryVertex[] = {{"_p_BoundaryVertex", 0, "BoundaryVertex *", 0},{"_p_BoundaryVertex"},{0}};
static swig_type_info _swigt__p_PSDrawMode[] = {{"_p_PSDrawMode", 0, "PSDrawMode *", 0},{"_p_PSDrawMode"},{0}};
static swig_type_info _swigt__p_Matrix[] = {{"_p_Matrix", 0, "Matrix *", 0},{"_p_Matrix"},{0}};
static swig_type_info _swigt__p_BoundaryMesh[] = {{"_p_BoundaryMesh", 0, "BoundaryMesh *", 0},{"_p_BoundaryMesh"},{0}};
static swig_type_info _swigt__p_EPSWrite[] = {{"_p_EPSWrite", 0, "EPSWrite *", 0},{"_p_EPSWrite"},{0}};
static swig_type_info _swigt__p_float[] = {{"_p_float", 0, "float *", 0},{"_p_float"},{0}};
static swig_type_info _swigt__p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t[] = {{"_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t", 0, "CellComplex<BoundaryVertex,BoundaryEdge,BoundaryFace,BoundaryTuple > *", 0},{"_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t"},{"_p_BoundaryMesh", _p_BoundaryMeshTo_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t},{0}};
static swig_type_info _swigt__p_listTLinearData_t[] = {{"_p_listTLinearData_t", 0, "list<LinearData > *", 0},{"_p_listTLinearData_t"},{0}};
static swig_type_info _swigt__p_dequeTBoundaryEdge_p_t[] = {{"_p_dequeTBoundaryEdge_p_t", 0, "deque<BoundaryEdge * > *", 0},{"_p_dequeTBoundaryEdge_p_t"},{0}};
static swig_type_info _swigt__p_listTBoundaryEdge_p_t[] = {{"_p_listTBoundaryEdge_p_t", 0, "list<BoundaryEdge * > *", 0},{"_p_listTBoundaryEdge_p_t"},{0}};
static swig_type_info _swigt__p_vectorTBoundaryEdge_p_t[] = {{"_p_vectorTBoundaryEdge_p_t", 0, "vector<BoundaryEdge * > *", 0},{"_p_vectorTBoundaryEdge_p_t"},{0}};
static swig_type_info _swigt__p_dequeTBezierEdge_p_t[] = {{"_p_dequeTBezierEdge_p_t", 0, "deque<BezierEdge * > *", 0},{"_p_dequeTBezierEdge_p_t"},{0}};
static swig_type_info _swigt__p_listTBezierEdge_p_t[] = {{"_p_listTBezierEdge_p_t", 0, "list<BezierEdge * > *", 0},{"_p_listTBezierEdge_p_t"},{0}};
static swig_type_info _swigt__p_vectorTBezierEdge_p_t[] = {{"_p_vectorTBezierEdge_p_t", 0, "vector<BezierEdge * > *", 0},{"_p_vectorTBezierEdge_p_t"},{0}};
static swig_type_info _swigt__p_p_BezierTriangle[] = {{"_p_p_BezierTriangle", 0, "BezierTriangle **", 0},{"_p_p_BezierTriangle"},{0}};
static swig_type_info _swigt__p_CurvedTriangle[] = {{"_p_CurvedTriangle", 0, "CurvedTriangle *", 0},{"_p_CurvedTriangle"},{"_p_BezierTriangle", _p_BezierTriangleTo_p_CurvedTriangle},{"_p_GhostTriangle", _p_GhostTriangleTo_p_CurvedTriangle},{0}};
static swig_type_info _swigt__p_BezierTriangle[] = {{"_p_BezierTriangle", 0, "BezierTriangle *", 0},{"_p_BezierTriangle"},{0}};
static swig_type_info _swigt__p_GhostTriangle[] = {{"_p_GhostTriangle", 0, "GhostTriangle *", 0},{"_p_GhostTriangle"},{0}};
static swig_type_info _swigt__p_BoundaryTuple[] = {{"_p_BoundaryTuple", 0, "BoundaryTuple *", 0},{"_p_BoundaryTuple"},{"_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t"},{0}};

static swig_type_info *swig_types_initial[] = {
_swigt__p_GrayscaleMap, 
_swigt__p_Cell, 
_swigt__p_ControlPoint, 
_swigt__p_hash_setTBoundaryFace_p_CellHasherTBoundaryFace_t_CellEqualTBoundaryFace_t_t, 
_swigt__p_BoundaryFace, 
_swigt__p_Color, 
_swigt__p_Pump, 
_swigt__p_hash_mapTlistTPoint2D_t__iterator_listTLinearData_t__iterator_ControlPointHasher_ControlPointEqual_t, 
_swigt__p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t, 
_swigt__p_SlitCavity, 
_swigt__p_hash_setTBezierEdge_p_CellHasherTBezierEdge_t_CellEqualTBezierEdge_t_t, 
_swigt__p_BezierVertex, 
_swigt__p_hash_setTBezierVertex_p_CellHasherTBezierVertex_t_CellEqualTBezierVertex_t_t, 
_swigt__p_Simulation, 
_swigt__p_Visualization, 
_swigt__p_PSCoord, 
_swigt__p_vectorTlistTPoint2D_t__iterator_t, 
_swigt__p_hash_setTBoundaryVertex_p_CellHasherTBoundaryVertex_t_CellEqualTBoundaryVertex_t_t, 
_swigt__p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t, 
_swigt__p_FaceCell, 
_swigt__p_MeshConstructor, 
_swigt__p_Point2D, 
_swigt__p_p_void, 
_swigt__p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, 
_swigt__p_double, 
_swigt__p_p_double, 
_swigt__p_int, 
_swigt__p_MeshInput, 
_swigt__p_VertexCell, 
_swigt__p_dequeTBezierTriangle_p_t, 
_swigt__p_listTBezierTriangle_p_t, 
_swigt__p_vectorTBezierTriangle_p_t, 
_swigt__p_LinearData, 
_swigt__p_EdgeCell, 
_swigt__p_p_BezierEdge, 
_swigt__p_BezierEdge, 
_swigt__p_DataPoint, 
_swigt__p_hash_setTBezierTriangle_p_CellHasherTBezierTriangle_t_CellEqualTBezierTriangle_t_t, 
_swigt__p_vectorTdouble_t, 
_swigt__p_Matrix5, 
_swigt__p_TimeKeeper, 
_swigt__p_QBSpline, 
_swigt__p_ColorMap, 
_swigt__p_MeshOutput, 
_swigt__p_dequeTBoundaryFace_p_t, 
_swigt__p_listTBoundaryFace_p_t, 
_swigt__p_vectorTBoundaryFace_p_t, 
_swigt__p_BezierMesh, 
_swigt__p_hash_setTBoundaryEdge_p_CellHasherTBoundaryEdge_t_CellEqualTBoundaryEdge_t_t, 
_swigt__p_p_BoundaryEdge, 
_swigt__p_BoundaryEdge, 
_swigt__p_BezierTuple, 
_swigt__p_listTBoundaryVertex_p_t, 
_swigt__p_vectorTBoundaryVertex_p_t, 
_swigt__p_listTBezierVertex_p_t, 
_swigt__p_vectorTBezierVertex_p_t, 
_swigt__p_vectorTPoint2D_t, 
_swigt__p_listTPoint2D_t, 
_swigt__p_BoundaryVertex, 
_swigt__p_PSDrawMode, 
_swigt__p_Matrix, 
_swigt__p_BoundaryMesh, 
_swigt__p_EPSWrite, 
_swigt__p_float, 
_swigt__p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, 
_swigt__p_listTLinearData_t, 
_swigt__p_dequeTBoundaryEdge_p_t, 
_swigt__p_listTBoundaryEdge_p_t, 
_swigt__p_vectorTBoundaryEdge_p_t, 
_swigt__p_dequeTBezierEdge_p_t, 
_swigt__p_listTBezierEdge_p_t, 
_swigt__p_vectorTBezierEdge_p_t, 
_swigt__p_p_BezierTriangle, 
_swigt__p_CurvedTriangle, 
_swigt__p_BezierTriangle, 
_swigt__p_GhostTriangle, 
_swigt__p_BoundaryTuple, 
0
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */


#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT(void) Init_Tumble(void) {
    int i;
    
    SWIG_InitRuntime();
    mTumble = rb_define_module("Tumble");
    
    for (i = 0; swig_types_initial[i]; i++) {
        swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
        SWIG_define_class(swig_types[i]);
    }
    
    rb_define_const(mTumble,"DEFUALT_BDRY_CELL_HASH_TABLE_SIZE", INT2NUM(100));
    rb_define_const(mTumble,"DEFUALT_BDRY_TUPLE_HASH_TABLE_SIZE", INT2NUM(300));
    rb_define_const(mTumble,"DEFUALT_BEZIER_CELL_HASH_TABLE_SIZE", INT2NUM(300000));
    rb_define_const(mTumble,"DEFUALT_BEZIER_TUPLE_HASH_TABLE_SIZE", INT2NUM(900000));
    rb_define_const(mTumble,"MAX_FILENAME", INT2NUM(240));
    rb_define_const(mTumble,"MAX_FILE_LINE", INT2NUM(8092));
    rb_define_const(mTumble,"FALSE", INT2NUM(0));
    rb_define_const(mTumble,"TRUE", INT2NUM(1));
    rb_define_const(mTumble,"CONCAVE_THRESHOLD", rb_float_new(0.00002));
    rb_define_const(mTumble,"BIG", INT2NUM(100));
    rb_define_const(mTumble,"CONSTRAINT_RATIO", rb_float_new(3.0));
    rb_define_singleton_method(mTumble, "ALPHA", VALUEFUNC(ALPHA_get), 0);
    rb_define_singleton_method(mTumble, "BETA", VALUEFUNC(BETA_get), 0);
    rb_define_singleton_method(mTumble, "WEIGHT", VALUEFUNC(WEIGHT_get), 0);
    rb_define_singleton_method(mTumble, "PI", VALUEFUNC(PI_get), 0);
    rb_define_singleton_method(mTumble, "TWOPI", VALUEFUNC(TWOPI_get), 0);
    rb_define_singleton_method(mTumble, "HALFPI", VALUEFUNC(HALFPI_get), 0);
    
    cPoint2D.klass = rb_define_class_under(mTumble, "Point2D", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_Point2D, (void *) &cPoint2D);
    rb_define_alloc_func(cPoint2D.klass, _wrap_Point2D_allocate);
    rb_define_method(cPoint2D.klass, "initialize", VALUEFUNC(_wrap_new_Point2D), -1);
    rb_define_method(cPoint2D.klass, "coords=", VALUEFUNC(_wrap_Point2D_coords_set), -1);
    rb_define_method(cPoint2D.klass, "coords", VALUEFUNC(_wrap_Point2D_coords_get), -1);
    rb_define_method(cPoint2D.klass, "assign", VALUEFUNC(_wrap_Point2D_assign), -1);
    rb_define_method(cPoint2D.klass, "at", VALUEFUNC(_wrap_Point2D_at), -1);
    rb_define_method(cPoint2D.klass, "x", VALUEFUNC(_wrap_Point2D_x), -1);
    rb_define_method(cPoint2D.klass, "y", VALUEFUNC(_wrap_Point2D_y), -1);
    rb_define_method(cPoint2D.klass, "==", VALUEFUNC(_wrap_Point2D___eq__), -1);
    rb_define_method(cPoint2D.klass, "<", VALUEFUNC(_wrap_Point2D___lt__), -1);
    rb_define_method(cPoint2D.klass, "<=", VALUEFUNC(_wrap_Point2D___le__), -1);
    rb_define_method(cPoint2D.klass, ">", VALUEFUNC(_wrap_Point2D___gt__), -1);
    rb_define_method(cPoint2D.klass, ">=", VALUEFUNC(_wrap_Point2D___ge__), -1);
    rb_define_method(cPoint2D.klass, "+", VALUEFUNC(_wrap_Point2D___add__), -1);
    rb_define_method(cPoint2D.klass, "-", VALUEFUNC(_wrap_Point2D___sub__), -1);
    rb_define_method(cPoint2D.klass, "*", VALUEFUNC(_wrap_Point2D___mul__), -1);
    rb_define_method(cPoint2D.klass, "/", VALUEFUNC(_wrap_Point2D___div__), -1);
    rb_define_method(cPoint2D.klass, "dot", VALUEFUNC(_wrap_Point2D_dot), -1);
    rb_define_method(cPoint2D.klass, "magsq", VALUEFUNC(_wrap_Point2D_magsq), -1);
    rb_define_method(cPoint2D.klass, "mag", VALUEFUNC(_wrap_Point2D_mag), -1);
    rb_define_method(cPoint2D.klass, "cross", VALUEFUNC(_wrap_Point2D_cross), -1);
    rb_define_method(cPoint2D.klass, "is_left_of", VALUEFUNC(_wrap_Point2D_is_left_of), -1);
    rb_define_method(cPoint2D.klass, "is_right_of", VALUEFUNC(_wrap_Point2D_is_right_of), -1);
    rb_define_method(cPoint2D.klass, "line_side_test", VALUEFUNC(_wrap_Point2D_line_side_test), -1);
    rb_define_method(cPoint2D.klass, "in_circle_test", VALUEFUNC(_wrap_Point2D_in_circle_test), -1);
    rb_define_method(cPoint2D.klass, "dist_from_line", VALUEFUNC(_wrap_Point2D_dist_from_line), -1);
    rb_define_method(cPoint2D.klass, "print", VALUEFUNC(_wrap_Point2D_print), -1);
    cPoint2D.mark = 0;
    cPoint2D.destroy = (void (*)(void *)) free_Point2D;
    
    cLinearData.klass = rb_define_class_under(mTumble, "LinearData", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_LinearData, (void *) &cLinearData);
    rb_define_alloc_func(cLinearData.klass, _wrap_LinearData_allocate);
    rb_define_method(cLinearData.klass, "initialize", VALUEFUNC(_wrap_new_LinearData), -1);
    rb_define_method(cLinearData.klass, "fields=", VALUEFUNC(_wrap_LinearData_fields_set), -1);
    rb_define_method(cLinearData.klass, "fields", VALUEFUNC(_wrap_LinearData_fields_get), -1);
    rb_define_method(cLinearData.klass, "length=", VALUEFUNC(_wrap_LinearData_length_set), -1);
    rb_define_method(cLinearData.klass, "length", VALUEFUNC(_wrap_LinearData_length_get), -1);
    rb_define_method(cLinearData.klass, "update", VALUEFUNC(_wrap_LinearData_update), -1);
    rb_define_method(cLinearData.klass, "zero", VALUEFUNC(_wrap_LinearData_zero), -1);
    rb_define_method(cLinearData.klass, "set", VALUEFUNC(_wrap_LinearData_set), -1);
    rb_define_method(cLinearData.klass, "at", VALUEFUNC(_wrap_LinearData_at), -1);
    rb_define_method(cLinearData.klass, "get", VALUEFUNC(_wrap_LinearData_get), -1);
    rb_define_method(cLinearData.klass, "+", VALUEFUNC(_wrap_LinearData___add__), -1);
    rb_define_method(cLinearData.klass, "-", VALUEFUNC(_wrap_LinearData___sub__), -1);
    rb_define_method(cLinearData.klass, "*", VALUEFUNC(_wrap_LinearData___mul__), -1);
    rb_define_method(cLinearData.klass, "/", VALUEFUNC(_wrap_LinearData___div__), -1);
    rb_define_method(cLinearData.klass, "print", VALUEFUNC(_wrap_LinearData_print), -1);
    cLinearData.mark = 0;
    cLinearData.destroy = (void (*)(void *)) free_LinearData;
    
    cMatrix.klass = rb_define_class_under(mTumble, "Matrix", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_Matrix, (void *) &cMatrix);
    rb_define_alloc_func(cMatrix.klass, _wrap_Matrix_allocate);
    rb_define_method(cMatrix.klass, "initialize", VALUEFUNC(_wrap_new_Matrix), -1);
    rb_define_method(cMatrix.klass, "m=", VALUEFUNC(_wrap_Matrix_m_set), -1);
    rb_define_method(cMatrix.klass, "m", VALUEFUNC(_wrap_Matrix_m_get), -1);
    rb_define_method(cMatrix.klass, "rows=", VALUEFUNC(_wrap_Matrix_rows_set), -1);
    rb_define_method(cMatrix.klass, "rows", VALUEFUNC(_wrap_Matrix_rows_get), -1);
    rb_define_method(cMatrix.klass, "cols=", VALUEFUNC(_wrap_Matrix_cols_set), -1);
    rb_define_method(cMatrix.klass, "cols", VALUEFUNC(_wrap_Matrix_cols_get), -1);
    rb_define_method(cMatrix.klass, "call", VALUEFUNC(_wrap_Matrix___call__), -1);
    rb_define_method(cMatrix.klass, "set", VALUEFUNC(_wrap_Matrix_set), -1);
    rb_define_method(cMatrix.klass, "det", VALUEFUNC(_wrap_Matrix_det), -1);
    rb_define_method(cMatrix.klass, "transpose_times_self", VALUEFUNC(_wrap_Matrix_transpose_times_self), -1);
    rb_define_method(cMatrix.klass, "inverse", VALUEFUNC(_wrap_Matrix_inverse), -1);
    rb_define_method(cMatrix.klass, "transpose_times_vector", VALUEFUNC(_wrap_Matrix_transpose_times_vector), -1);
    rb_define_method(cMatrix.klass, "times_vector", VALUEFUNC(_wrap_Matrix_times_vector), -1);
    rb_define_method(cMatrix.klass, "print", VALUEFUNC(_wrap_Matrix_print), -1);
    cMatrix.mark = 0;
    cMatrix.destroy = (void (*)(void *)) free_Matrix;
    
    cMatrix5.klass = rb_define_class_under(mTumble, "Matrix5", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_Matrix5, (void *) &cMatrix5);
    rb_define_alloc_func(cMatrix5.klass, _wrap_Matrix5_allocate);
    rb_define_method(cMatrix5.klass, "initialize", VALUEFUNC(_wrap_new_Matrix5), -1);
    rb_define_method(cMatrix5.klass, "size=", VALUEFUNC(_wrap_Matrix5_size_set), -1);
    rb_define_method(cMatrix5.klass, "size", VALUEFUNC(_wrap_Matrix5_size_get), -1);
    rb_define_method(cMatrix5.klass, "d1=", VALUEFUNC(_wrap_Matrix5_d1_set), -1);
    rb_define_method(cMatrix5.klass, "d1", VALUEFUNC(_wrap_Matrix5_d1_get), -1);
    rb_define_method(cMatrix5.klass, "d2=", VALUEFUNC(_wrap_Matrix5_d2_set), -1);
    rb_define_method(cMatrix5.klass, "d2", VALUEFUNC(_wrap_Matrix5_d2_get), -1);
    rb_define_method(cMatrix5.klass, "d3=", VALUEFUNC(_wrap_Matrix5_d3_set), -1);
    rb_define_method(cMatrix5.klass, "d3", VALUEFUNC(_wrap_Matrix5_d3_get), -1);
    rb_define_method(cMatrix5.klass, "d4=", VALUEFUNC(_wrap_Matrix5_d4_set), -1);
    rb_define_method(cMatrix5.klass, "d4", VALUEFUNC(_wrap_Matrix5_d4_get), -1);
    rb_define_method(cMatrix5.klass, "d5=", VALUEFUNC(_wrap_Matrix5_d5_set), -1);
    rb_define_method(cMatrix5.klass, "d5", VALUEFUNC(_wrap_Matrix5_d5_get), -1);
    rb_define_method(cMatrix5.klass, "factored=", VALUEFUNC(_wrap_Matrix5_factored_set), -1);
    rb_define_method(cMatrix5.klass, "factored", VALUEFUNC(_wrap_Matrix5_factored_get), -1);
    rb_define_method(cMatrix5.klass, "LUsolve", VALUEFUNC(_wrap_Matrix5_LUsolve), -1);
    cMatrix5.mark = 0;
    cMatrix5.destroy = (void (*)(void *)) free_Matrix5;
    rb_define_module_function(mTumble, "add_filename_extension", VALUEFUNC(_wrap_add_filename_extension), -1);
    rb_define_const(mTumble,"FIXED_NONE", INT2NUM(0));
    rb_define_const(mTumble,"FIXED_HORIZONTAL", INT2NUM(1));
    rb_define_const(mTumble,"FIXED_VERTICAL", INT2NUM(2));
    rb_define_const(mTumble,"FIXED_ALL", INT2NUM(3));
    
    cCell.klass = rb_define_class_under(mTumble, "Cell", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_Cell, (void *) &cCell);
    rb_define_alloc_func(cCell.klass, _wrap_Cell_allocate);
    rb_define_method(cCell.klass, "initialize", VALUEFUNC(_wrap_new_Cell), -1);
    cCell.mark = 0;
    cCell.destroy = (void (*)(void *)) free_Cell;
    
    cVertexCell.klass = rb_define_class_under(mTumble, "VertexCell", ((swig_class *) SWIGTYPE_p_Cell->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_VertexCell, (void *) &cVertexCell);
    rb_define_alloc_func(cVertexCell.klass, _wrap_VertexCell_allocate);
    rb_define_method(cVertexCell.klass, "initialize", VALUEFUNC(_wrap_new_VertexCell), -1);
    rb_define_method(cVertexCell.klass, "num_edges=", VALUEFUNC(_wrap_VertexCell_num_edges_set), -1);
    rb_define_method(cVertexCell.klass, "num_edges", VALUEFUNC(_wrap_VertexCell_num_edges_get), -1);
    rb_define_method(cVertexCell.klass, "max_edges=", VALUEFUNC(_wrap_VertexCell_max_edges_set), -1);
    rb_define_method(cVertexCell.klass, "max_edges", VALUEFUNC(_wrap_VertexCell_max_edges_get), -1);
    rb_define_method(cVertexCell.klass, "edges=", VALUEFUNC(_wrap_VertexCell_edges_set), -1);
    rb_define_method(cVertexCell.klass, "edges", VALUEFUNC(_wrap_VertexCell_edges_get), -1);
    rb_define_method(cVertexCell.klass, "add_edge", VALUEFUNC(_wrap_VertexCell_add_edge), -1);
    rb_define_method(cVertexCell.klass, "delete_edge", VALUEFUNC(_wrap_VertexCell_delete_edge), -1);
    cVertexCell.mark = 0;
    cVertexCell.destroy = (void (*)(void *)) free_VertexCell;
    
    cEdgeCell.klass = rb_define_class_under(mTumble, "EdgeCell", ((swig_class *) SWIGTYPE_p_Cell->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_EdgeCell, (void *) &cEdgeCell);
    rb_define_alloc_func(cEdgeCell.klass, _wrap_EdgeCell_allocate);
    rb_define_method(cEdgeCell.klass, "initialize", VALUEFUNC(_wrap_new_EdgeCell), -1);
    rb_define_method(cEdgeCell.klass, "vertexs=", VALUEFUNC(_wrap_EdgeCell_vertexs_set), -1);
    rb_define_method(cEdgeCell.klass, "vertexs", VALUEFUNC(_wrap_EdgeCell_vertexs_get), -1);
    rb_define_method(cEdgeCell.klass, "faces=", VALUEFUNC(_wrap_EdgeCell_faces_set), -1);
    rb_define_method(cEdgeCell.klass, "faces", VALUEFUNC(_wrap_EdgeCell_faces_get), -1);
    rb_define_method(cEdgeCell.klass, "add_face", VALUEFUNC(_wrap_EdgeCell_add_face), -1);
    rb_define_method(cEdgeCell.klass, "delete_face", VALUEFUNC(_wrap_EdgeCell_delete_face), -1);
    cEdgeCell.mark = 0;
    cEdgeCell.destroy = (void (*)(void *)) free_EdgeCell;
    
    cFaceCell.klass = rb_define_class_under(mTumble, "FaceCell", ((swig_class *) SWIGTYPE_p_Cell->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_FaceCell, (void *) &cFaceCell);
    rb_define_alloc_func(cFaceCell.klass, _wrap_FaceCell_allocate);
    rb_define_method(cFaceCell.klass, "initialize", VALUEFUNC(_wrap_new_FaceCell), -1);
    rb_define_method(cFaceCell.klass, "num_edges=", VALUEFUNC(_wrap_FaceCell_num_edges_set), -1);
    rb_define_method(cFaceCell.klass, "num_edges", VALUEFUNC(_wrap_FaceCell_num_edges_get), -1);
    rb_define_method(cFaceCell.klass, "max_edges=", VALUEFUNC(_wrap_FaceCell_max_edges_set), -1);
    rb_define_method(cFaceCell.klass, "max_edges", VALUEFUNC(_wrap_FaceCell_max_edges_get), -1);
    rb_define_method(cFaceCell.klass, "edges=", VALUEFUNC(_wrap_FaceCell_edges_set), -1);
    rb_define_method(cFaceCell.klass, "edges", VALUEFUNC(_wrap_FaceCell_edges_get), -1);
    rb_define_method(cFaceCell.klass, "add_edge", VALUEFUNC(_wrap_FaceCell_add_edge), -1);
    rb_define_method(cFaceCell.klass, "delete_edge", VALUEFUNC(_wrap_FaceCell_delete_edge), -1);
    rb_define_method(cFaceCell.klass, "has_vertex", VALUEFUNC(_wrap_FaceCell_has_vertex), -1);
    cFaceCell.mark = 0;
    cFaceCell.destroy = (void (*)(void *)) free_FaceCell;
    
    cBoundaryVertex.klass = rb_define_class_under(mTumble, "BoundaryVertex", ((swig_class *) SWIGTYPE_p_VertexCell->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_BoundaryVertex, (void *) &cBoundaryVertex);
    rb_define_alloc_func(cBoundaryVertex.klass, _wrap_BoundaryVertex_allocate);
    rb_define_method(cBoundaryVertex.klass, "initialize", VALUEFUNC(_wrap_new_BoundaryVertex), -1);
    rb_define_method(cBoundaryVertex.klass, "cp=", VALUEFUNC(_wrap_BoundaryVertex_cp_set), -1);
    rb_define_method(cBoundaryVertex.klass, "cp", VALUEFUNC(_wrap_BoundaryVertex_cp_get), -1);
    rb_define_method(cBoundaryVertex.klass, "fixed=", VALUEFUNC(_wrap_BoundaryVertex_fixed_set), -1);
    rb_define_method(cBoundaryVertex.klass, "fixed", VALUEFUNC(_wrap_BoundaryVertex_fixed_get), -1);
    rb_define_method(cBoundaryVertex.klass, "bezier_vertex=", VALUEFUNC(_wrap_BoundaryVertex_bezier_vertex_set), -1);
    rb_define_method(cBoundaryVertex.klass, "bezier_vertex", VALUEFUNC(_wrap_BoundaryVertex_bezier_vertex_get), -1);
    rb_define_method(cBoundaryVertex.klass, "set_fixed", VALUEFUNC(_wrap_BoundaryVertex_set_fixed), -1);
    rb_define_method(cBoundaryVertex.klass, "set_cp", VALUEFUNC(_wrap_BoundaryVertex_set_cp), -1);
    rb_define_method(cBoundaryVertex.klass, "print", VALUEFUNC(_wrap_BoundaryVertex_print), -1);
    rb_define_method(cBoundaryVertex.klass, "get_cp", VALUEFUNC(_wrap_BoundaryVertex_get_cp), -1);
    rb_define_method(cBoundaryVertex.klass, "get_edge", VALUEFUNC(_wrap_BoundaryVertex_get_edge), -1);
    cBoundaryVertex.mark = 0;
    cBoundaryVertex.destroy = (void (*)(void *)) free_BoundaryVertex;
    
    cBoundaryEdge.klass = rb_define_class_under(mTumble, "BoundaryEdge", ((swig_class *) SWIGTYPE_p_EdgeCell->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_BoundaryEdge, (void *) &cBoundaryEdge);
    rb_define_alloc_func(cBoundaryEdge.klass, _wrap_BoundaryEdge_allocate);
    rb_define_method(cBoundaryEdge.klass, "initialize", VALUEFUNC(_wrap_new_BoundaryEdge), -1);
    rb_define_method(cBoundaryEdge.klass, "spline=", VALUEFUNC(_wrap_BoundaryEdge_spline_set), -1);
    rb_define_method(cBoundaryEdge.klass, "spline", VALUEFUNC(_wrap_BoundaryEdge_spline_get), -1);
    rb_define_method(cBoundaryEdge.klass, "fixed=", VALUEFUNC(_wrap_BoundaryEdge_fixed_set), -1);
    rb_define_method(cBoundaryEdge.klass, "fixed", VALUEFUNC(_wrap_BoundaryEdge_fixed_get), -1);
    rb_define_method(cBoundaryEdge.klass, "color=", VALUEFUNC(_wrap_BoundaryEdge_color_set), -1);
    rb_define_method(cBoundaryEdge.klass, "color", VALUEFUNC(_wrap_BoundaryEdge_color_get), -1);
    rb_define_method(cBoundaryEdge.klass, "set_fixed", VALUEFUNC(_wrap_BoundaryEdge_set_fixed), -1);
    rb_define_method(cBoundaryEdge.klass, "set_color", VALUEFUNC(_wrap_BoundaryEdge_set_color), -1);
    rb_define_method(cBoundaryEdge.klass, "set_restlength", VALUEFUNC(_wrap_BoundaryEdge_set_restlength), -1);
    rb_define_method(cBoundaryEdge.klass, "print", VALUEFUNC(_wrap_BoundaryEdge_print), -1);
    rb_define_method(cBoundaryEdge.klass, "get_vertex", VALUEFUNC(_wrap_BoundaryEdge_get_vertex), -1);
    rb_define_method(cBoundaryEdge.klass, "get_face", VALUEFUNC(_wrap_BoundaryEdge_get_face), -1);
    cBoundaryEdge.mark = 0;
    cBoundaryEdge.destroy = (void (*)(void *)) free_BoundaryEdge;
    
    cBoundaryFace.klass = rb_define_class_under(mTumble, "BoundaryFace", ((swig_class *) SWIGTYPE_p_FaceCell->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_BoundaryFace, (void *) &cBoundaryFace);
    rb_define_alloc_func(cBoundaryFace.klass, _wrap_BoundaryFace_allocate);
    rb_define_method(cBoundaryFace.klass, "initialize", VALUEFUNC(_wrap_new_BoundaryFace), -1);
    rb_define_method(cBoundaryFace.klass, "min_angle=", VALUEFUNC(_wrap_BoundaryFace_min_angle_set), -1);
    rb_define_method(cBoundaryFace.klass, "min_angle", VALUEFUNC(_wrap_BoundaryFace_min_angle_get), -1);
    rb_define_method(cBoundaryFace.klass, "color=", VALUEFUNC(_wrap_BoundaryFace_color_set), -1);
    rb_define_method(cBoundaryFace.klass, "color", VALUEFUNC(_wrap_BoundaryFace_color_get), -1);
    rb_define_method(cBoundaryFace.klass, "set_min_angle", VALUEFUNC(_wrap_BoundaryFace_set_min_angle), -1);
    rb_define_method(cBoundaryFace.klass, "set_color", VALUEFUNC(_wrap_BoundaryFace_set_color), -1);
    rb_define_method(cBoundaryFace.klass, "print", VALUEFUNC(_wrap_BoundaryFace_print), -1);
    rb_define_method(cBoundaryFace.klass, "get_edge", VALUEFUNC(_wrap_BoundaryFace_get_edge), -1);
    cBoundaryFace.mark = 0;
    cBoundaryFace.destroy = (void (*)(void *)) free_BoundaryFace;
    
    cBezierVertex.klass = rb_define_class_under(mTumble, "BezierVertex", ((swig_class *) SWIGTYPE_p_VertexCell->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_BezierVertex, (void *) &cBezierVertex);
    rb_define_alloc_func(cBezierVertex.klass, _wrap_BezierVertex_allocate);
    rb_define_method(cBezierVertex.klass, "initialize", VALUEFUNC(_wrap_new_BezierVertex), -1);
    rb_define_method(cBezierVertex.klass, "cp=", VALUEFUNC(_wrap_BezierVertex_cp_set), -1);
    rb_define_method(cBezierVertex.klass, "cp", VALUEFUNC(_wrap_BezierVertex_cp_get), -1);
    rb_define_method(cBezierVertex.klass, "dp=", VALUEFUNC(_wrap_BezierVertex_dp_set), -1);
    rb_define_method(cBezierVertex.klass, "dp", VALUEFUNC(_wrap_BezierVertex_dp_get), -1);
    rb_define_method(cBezierVertex.klass, "bdry_edge=", VALUEFUNC(_wrap_BezierVertex_bdry_edge_set), -1);
    rb_define_method(cBezierVertex.klass, "bdry_edge", VALUEFUNC(_wrap_BezierVertex_bdry_edge_get), -1);
    rb_define_method(cBezierVertex.klass, "bdry_vertex=", VALUEFUNC(_wrap_BezierVertex_bdry_vertex_set), -1);
    rb_define_method(cBezierVertex.klass, "bdry_vertex", VALUEFUNC(_wrap_BezierVertex_bdry_vertex_get), -1);
    rb_define_method(cBezierVertex.klass, "u=", VALUEFUNC(_wrap_BezierVertex_u_set), -1);
    rb_define_method(cBezierVertex.klass, "u", VALUEFUNC(_wrap_BezierVertex_u_get), -1);
    rb_define_method(cBezierVertex.klass, "is_removeable=", VALUEFUNC(_wrap_BezierVertex_is_removeable_set), -1);
    rb_define_method(cBezierVertex.klass, "is_removeable", VALUEFUNC(_wrap_BezierVertex_is_removeable_get), -1);
    rb_define_method(cBezierVertex.klass, "set_bdry", VALUEFUNC(_wrap_BezierVertex_set_bdry), -1);
    rb_define_method(cBezierVertex.klass, "set_cp", VALUEFUNC(_wrap_BezierVertex_set_cp), -1);
    rb_define_method(cBezierVertex.klass, "set_dp", VALUEFUNC(_wrap_BezierVertex_set_dp), -1);
    rb_define_method(cBezierVertex.klass, "get_cp", VALUEFUNC(_wrap_BezierVertex_get_cp), -1);
    rb_define_method(cBezierVertex.klass, "get_dp", VALUEFUNC(_wrap_BezierVertex_get_dp), -1);
    rb_define_method(cBezierVertex.klass, "get_edge", VALUEFUNC(_wrap_BezierVertex_get_edge), -1);
    rb_define_method(cBezierVertex.klass, "get_u", VALUEFUNC(_wrap_BezierVertex_get_u), -1);
    rb_define_method(cBezierVertex.klass, "print", VALUEFUNC(_wrap_BezierVertex_print), -1);
    cBezierVertex.mark = 0;
    cBezierVertex.destroy = (void (*)(void *)) free_BezierVertex;
    
    cBezierEdge.klass = rb_define_class_under(mTumble, "BezierEdge", ((swig_class *) SWIGTYPE_p_EdgeCell->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_BezierEdge, (void *) &cBezierEdge);
    rb_define_alloc_func(cBezierEdge.klass, _wrap_BezierEdge_allocate);
    rb_define_method(cBezierEdge.klass, "initialize", VALUEFUNC(_wrap_new_BezierEdge), -1);
    rb_define_method(cBezierEdge.klass, "cp=", VALUEFUNC(_wrap_BezierEdge_cp_set), -1);
    rb_define_method(cBezierEdge.klass, "cp", VALUEFUNC(_wrap_BezierEdge_cp_get), -1);
    rb_define_method(cBezierEdge.klass, "dp=", VALUEFUNC(_wrap_BezierEdge_dp_set), -1);
    rb_define_method(cBezierEdge.klass, "dp", VALUEFUNC(_wrap_BezierEdge_dp_get), -1);
    rb_define_method(cBezierEdge.klass, "bdry=", VALUEFUNC(_wrap_BezierEdge_bdry_set), -1);
    rb_define_method(cBezierEdge.klass, "bdry", VALUEFUNC(_wrap_BezierEdge_bdry_get), -1);
    rb_define_method(cBezierEdge.klass, "u0=", VALUEFUNC(_wrap_BezierEdge_u0_set), -1);
    rb_define_method(cBezierEdge.klass, "u0", VALUEFUNC(_wrap_BezierEdge_u0_get), -1);
    rb_define_method(cBezierEdge.klass, "u1=", VALUEFUNC(_wrap_BezierEdge_u1_set), -1);
    rb_define_method(cBezierEdge.klass, "u1", VALUEFUNC(_wrap_BezierEdge_u1_get), -1);
    rb_define_method(cBezierEdge.klass, "set_bdry", VALUEFUNC(_wrap_BezierEdge_set_bdry), -1);
    rb_define_method(cBezierEdge.klass, "set_cp", VALUEFUNC(_wrap_BezierEdge_set_cp), -1);
    rb_define_method(cBezierEdge.klass, "set_dp", VALUEFUNC(_wrap_BezierEdge_set_dp), -1);
    rb_define_method(cBezierEdge.klass, "get_cp", VALUEFUNC(_wrap_BezierEdge_get_cp), -1);
    rb_define_method(cBezierEdge.klass, "get_dp", VALUEFUNC(_wrap_BezierEdge_get_dp), -1);
    rb_define_method(cBezierEdge.klass, "get_vertex", VALUEFUNC(_wrap_BezierEdge_get_vertex), -1);
    rb_define_method(cBezierEdge.klass, "get_face", VALUEFUNC(_wrap_BezierEdge_get_face), -1);
    rb_define_method(cBezierEdge.klass, "eval", VALUEFUNC(_wrap_BezierEdge_eval), -1);
    rb_define_method(cBezierEdge.klass, "dataeval", VALUEFUNC(_wrap_BezierEdge_dataeval), -1);
    rb_define_method(cBezierEdge.klass, "evalIntermediate", VALUEFUNC(_wrap_BezierEdge_evalIntermediate), -1);
    rb_define_method(cBezierEdge.klass, "dataevalIntermediate", VALUEFUNC(_wrap_BezierEdge_dataevalIntermediate), -1);
    rb_define_method(cBezierEdge.klass, "is_encroached", VALUEFUNC(_wrap_BezierEdge_is_encroached), -1);
    rb_define_method(cBezierEdge.klass, "left_of_curve", VALUEFUNC(_wrap_BezierEdge_left_of_curve), -1);
    rb_define_method(cBezierEdge.klass, "print", VALUEFUNC(_wrap_BezierEdge_print), -1);
    cBezierEdge.mark = 0;
    cBezierEdge.destroy = (void (*)(void *)) free_BezierEdge;
    rb_define_singleton_method(mTumble, "newton_optimal_tolerance", VALUEFUNC(newton_optimal_tolerance_get), 0);
    rb_define_singleton_method(mTumble, "newton_zero_tolerance", VALUEFUNC(newton_zero_tolerance_get), 0);
    rb_define_singleton_method(mTumble, "newton_tolerance", VALUEFUNC(newton_tolerance_get), 0);
    rb_define_singleton_method(mTumble, "newton_iterations", VALUEFUNC(newton_iterations_get), 0);
    
    cCurvedTriangle.klass = rb_define_class_under(mTumble, "CurvedTriangle", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_CurvedTriangle, (void *) &cCurvedTriangle);
    rb_undef_alloc_func(cCurvedTriangle.klass);
    rb_define_method(cCurvedTriangle.klass, "newton_find", VALUEFUNC(_wrap_CurvedTriangle_newton_find), -1);
    rb_define_method(cCurvedTriangle.klass, "jacobian_matrix", VALUEFUNC(_wrap_CurvedTriangle_jacobian_matrix), -1);
    rb_define_method(cCurvedTriangle.klass, "eval", VALUEFUNC(_wrap_CurvedTriangle_eval), -1);
    cCurvedTriangle.mark = 0;
    cCurvedTriangle.destroy = (void (*)(void *)) free_CurvedTriangle;
    
    cBezierTriangle.klass = rb_define_class_under(mTumble, "BezierTriangle", ((swig_class *) SWIGTYPE_p_FaceCell->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_BezierTriangle, (void *) &cBezierTriangle);
    rb_define_alloc_func(cBezierTriangle.klass, _wrap_BezierTriangle_allocate);
    rb_define_method(cBezierTriangle.klass, "initialize", VALUEFUNC(_wrap_new_BezierTriangle), -1);
    rb_define_method(cBezierTriangle.klass, "cp=", VALUEFUNC(_wrap_BezierTriangle_cp_set), -1);
    rb_define_method(cBezierTriangle.klass, "cp", VALUEFUNC(_wrap_BezierTriangle_cp_get), -1);
    rb_define_method(cBezierTriangle.klass, "dp=", VALUEFUNC(_wrap_BezierTriangle_dp_set), -1);
    rb_define_method(cBezierTriangle.klass, "dp", VALUEFUNC(_wrap_BezierTriangle_dp_get), -1);
    rb_define_method(cBezierTriangle.klass, "bdry_face=", VALUEFUNC(_wrap_BezierTriangle_bdry_face_set), -1);
    rb_define_method(cBezierTriangle.klass, "bdry_face", VALUEFUNC(_wrap_BezierTriangle_bdry_face_get), -1);
    rb_define_method(cBezierTriangle.klass, "set_cp", VALUEFUNC(_wrap_BezierTriangle_set_cp), -1);
    rb_define_method(cBezierTriangle.klass, "set_dp", VALUEFUNC(_wrap_BezierTriangle_set_dp), -1);
    rb_define_method(cBezierTriangle.klass, "get_cp", VALUEFUNC(_wrap_BezierTriangle_get_cp), -1);
    rb_define_method(cBezierTriangle.klass, "get_dp", VALUEFUNC(_wrap_BezierTriangle_get_dp), -1);
    rb_define_method(cBezierTriangle.klass, "get_edge", VALUEFUNC(_wrap_BezierTriangle_get_edge), -1);
    rb_define_method(cBezierTriangle.klass, "eval", VALUEFUNC(_wrap_BezierTriangle_eval), -1);
    rb_define_method(cBezierTriangle.klass, "dataeval", VALUEFUNC(_wrap_BezierTriangle_dataeval), -1);
    rb_define_method(cBezierTriangle.klass, "dataevalIntermediate", VALUEFUNC(_wrap_BezierTriangle_dataevalIntermediate), -1);
    rb_define_method(cBezierTriangle.klass, "evalIntermediate", VALUEFUNC(_wrap_BezierTriangle_evalIntermediate), -1);
    rb_define_method(cBezierTriangle.klass, "jacobian", VALUEFUNC(_wrap_BezierTriangle_jacobian), -1);
    rb_define_method(cBezierTriangle.klass, "jacobian_matrix", VALUEFUNC(_wrap_BezierTriangle_jacobian_matrix), -1);
    rb_define_method(cBezierTriangle.klass, "bound_jacobian", VALUEFUNC(_wrap_BezierTriangle_bound_jacobian), -1);
    rb_define_method(cBezierTriangle.klass, "small_angle", VALUEFUNC(_wrap_BezierTriangle_small_angle), -1);
    rb_define_method(cBezierTriangle.klass, "is_inverted", VALUEFUNC(_wrap_BezierTriangle_is_inverted), -1);
    rb_define_method(cBezierTriangle.klass, "circumcenter", VALUEFUNC(_wrap_BezierTriangle_circumcenter), -1);
    rb_define_method(cBezierTriangle.klass, "print", VALUEFUNC(_wrap_BezierTriangle_print), -1);
    rb_define_method(cBezierTriangle.klass, "print_mathematica", VALUEFUNC(_wrap_BezierTriangle_print_mathematica), -1);
    cBezierTriangle.mark = 0;
    cBezierTriangle.destroy = (void (*)(void *)) free_BezierTriangle;
    
    cGhostTriangle.klass = rb_define_class_under(mTumble, "GhostTriangle", ((swig_class *) SWIGTYPE_p_CurvedTriangle->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_GhostTriangle, (void *) &cGhostTriangle);
    rb_define_alloc_func(cGhostTriangle.klass, _wrap_GhostTriangle_allocate);
    rb_define_method(cGhostTriangle.klass, "initialize", VALUEFUNC(_wrap_new_GhostTriangle), -1);
    rb_define_method(cGhostTriangle.klass, "cp=", VALUEFUNC(_wrap_GhostTriangle_cp_set), -1);
    rb_define_method(cGhostTriangle.klass, "cp", VALUEFUNC(_wrap_GhostTriangle_cp_get), -1);
    rb_define_method(cGhostTriangle.klass, "dp=", VALUEFUNC(_wrap_GhostTriangle_dp_set), -1);
    rb_define_method(cGhostTriangle.klass, "dp", VALUEFUNC(_wrap_GhostTriangle_dp_get), -1);
    rb_define_method(cGhostTriangle.klass, "set_cp", VALUEFUNC(_wrap_GhostTriangle_set_cp), -1);
    rb_define_method(cGhostTriangle.klass, "get_cp", VALUEFUNC(_wrap_GhostTriangle_get_cp), -1);
    rb_define_method(cGhostTriangle.klass, "jacobian_matrix", VALUEFUNC(_wrap_GhostTriangle_jacobian_matrix), -1);
    rb_define_method(cGhostTriangle.klass, "jacobian", VALUEFUNC(_wrap_GhostTriangle_jacobian), -1);
    rb_define_method(cGhostTriangle.klass, "dataeval", VALUEFUNC(_wrap_GhostTriangle_dataeval), -1);
    rb_define_method(cGhostTriangle.klass, "eval", VALUEFUNC(_wrap_GhostTriangle_eval), -1);
    rb_define_method(cGhostTriangle.klass, "print", VALUEFUNC(_wrap_GhostTriangle_print), -1);
    rb_define_method(cGhostTriangle.klass, "print_mathematica", VALUEFUNC(_wrap_GhostTriangle_print_mathematica), -1);
    cGhostTriangle.mark = 0;
    cGhostTriangle.destroy = (void (*)(void *)) free_GhostTriangle;
    
    cBezierTuple.klass = rb_define_class_under(mTumble, "BezierTuple", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t, (void *) &cBezierTuple);
    rb_define_alloc_func(cBezierTuple.klass, _wrap_BezierTuple_allocate);
    rb_define_method(cBezierTuple.klass, "initialize", VALUEFUNC(_wrap_new_BezierTuple), -1);
    rb_define_method(cBezierTuple.klass, "v=", VALUEFUNC(_wrap_BezierTuple_v_set), -1);
    rb_define_method(cBezierTuple.klass, "v", VALUEFUNC(_wrap_BezierTuple_v_get), -1);
    rb_define_method(cBezierTuple.klass, "e=", VALUEFUNC(_wrap_BezierTuple_e_set), -1);
    rb_define_method(cBezierTuple.klass, "e", VALUEFUNC(_wrap_BezierTuple_e_get), -1);
    rb_define_method(cBezierTuple.klass, "f=", VALUEFUNC(_wrap_BezierTuple_f_set), -1);
    rb_define_method(cBezierTuple.klass, "f", VALUEFUNC(_wrap_BezierTuple_f_get), -1);
    rb_define_method(cBezierTuple.klass, "print", VALUEFUNC(_wrap_BezierTuple_print), -1);
    rb_define_method(cBezierTuple.klass, "print_detail", VALUEFUNC(_wrap_BezierTuple_print_detail), -1);
    cBezierTuple.mark = 0;
    cBezierTuple.destroy = (void (*)(void *)) free_CellTuplelBezierVertexcBezierEdgecBezierTriangle_g___;
    
    cBoundaryTuple.klass = rb_define_class_under(mTumble, "BoundaryTuple", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t, (void *) &cBoundaryTuple);
    rb_define_alloc_func(cBoundaryTuple.klass, _wrap_BoundaryTuple_allocate);
    rb_define_method(cBoundaryTuple.klass, "initialize", VALUEFUNC(_wrap_new_BoundaryTuple), -1);
    rb_define_method(cBoundaryTuple.klass, "v=", VALUEFUNC(_wrap_BoundaryTuple_v_set), -1);
    rb_define_method(cBoundaryTuple.klass, "v", VALUEFUNC(_wrap_BoundaryTuple_v_get), -1);
    rb_define_method(cBoundaryTuple.klass, "e=", VALUEFUNC(_wrap_BoundaryTuple_e_set), -1);
    rb_define_method(cBoundaryTuple.klass, "e", VALUEFUNC(_wrap_BoundaryTuple_e_get), -1);
    rb_define_method(cBoundaryTuple.klass, "f=", VALUEFUNC(_wrap_BoundaryTuple_f_set), -1);
    rb_define_method(cBoundaryTuple.klass, "f", VALUEFUNC(_wrap_BoundaryTuple_f_get), -1);
    rb_define_method(cBoundaryTuple.klass, "print", VALUEFUNC(_wrap_BoundaryTuple_print), -1);
    rb_define_method(cBoundaryTuple.klass, "print_detail", VALUEFUNC(_wrap_BoundaryTuple_print_detail), -1);
    cBoundaryTuple.mark = 0;
    cBoundaryTuple.destroy = (void (*)(void *)) free_CellTuplelBoundaryVertexcBoundaryEdgecBoundaryFace_g___;
    
    cQBSpline.klass = rb_define_class_under(mTumble, "QBSpline", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_QBSpline, (void *) &cQBSpline);
    rb_define_alloc_func(cQBSpline.klass, _wrap_QBSpline_allocate);
    rb_define_method(cQBSpline.klass, "initialize", VALUEFUNC(_wrap_new_QBSpline), -1);
    rb_define_method(cQBSpline.klass, "b=", VALUEFUNC(_wrap_QBSpline_b_set), -1);
    rb_define_method(cQBSpline.klass, "b", VALUEFUNC(_wrap_QBSpline_b_get), -1);
    rb_define_method(cQBSpline.klass, "k=", VALUEFUNC(_wrap_QBSpline_k_set), -1);
    rb_define_method(cQBSpline.klass, "k", VALUEFUNC(_wrap_QBSpline_k_get), -1);
    rb_define_method(cQBSpline.klass, "vertexs=", VALUEFUNC(_wrap_QBSpline_vertexs_set), -1);
    rb_define_method(cQBSpline.klass, "vertexs", VALUEFUNC(_wrap_QBSpline_vertexs_get), -1);
    rb_define_method(cQBSpline.klass, "closed=", VALUEFUNC(_wrap_QBSpline_closed_set), -1);
    rb_define_method(cQBSpline.klass, "closed", VALUEFUNC(_wrap_QBSpline_closed_get), -1);
    rb_define_method(cQBSpline.klass, "restlength=", VALUEFUNC(_wrap_QBSpline_restlength_set), -1);
    rb_define_method(cQBSpline.klass, "restlength", VALUEFUNC(_wrap_QBSpline_restlength_get), -1);
    rb_define_method(cQBSpline.klass, "bdry_mesh=", VALUEFUNC(_wrap_QBSpline_bdry_mesh_set), -1);
    rb_define_method(cQBSpline.klass, "bdry_mesh", VALUEFUNC(_wrap_QBSpline_bdry_mesh_get), -1);
    rb_define_method(cQBSpline.klass, "set_bezier_vertex", VALUEFUNC(_wrap_QBSpline_set_bezier_vertex), -1);
    rb_define_method(cQBSpline.klass, "move", VALUEFUNC(_wrap_QBSpline_move), -1);
    rb_define_method(cQBSpline.klass, "add_knot", VALUEFUNC(_wrap_QBSpline_add_knot), -1);
    rb_define_method(cQBSpline.klass, "remove_knot", VALUEFUNC(_wrap_QBSpline_remove_knot), -1);
    rb_define_method(cQBSpline.klass, "get_num_segments", VALUEFUNC(_wrap_QBSpline_get_num_segments), -1);
    rb_define_method(cQBSpline.klass, "get_num_deboor", VALUEFUNC(_wrap_QBSpline_get_num_deboor), -1);
    rb_define_method(cQBSpline.klass, "get_deboor", VALUEFUNC(_wrap_QBSpline_get_deboor), -1);
    rb_define_method(cQBSpline.klass, "getip", VALUEFUNC(_wrap_QBSpline_getip), -1);
    rb_define_method(cQBSpline.klass, "evaluate", VALUEFUNC(_wrap_QBSpline_evaluate), -1);
    rb_define_method(cQBSpline.klass, "evaluate_segment", VALUEFUNC(_wrap_QBSpline_evaluate_segment), -1);
    rb_define_method(cQBSpline.klass, "get_closest_knot", VALUEFUNC(_wrap_QBSpline_get_closest_knot), -1);
    rb_define_method(cQBSpline.klass, "get_closest_bezier", VALUEFUNC(_wrap_QBSpline_get_closest_bezier), -1);
    rb_define_method(cQBSpline.klass, "get_edge_cps", VALUEFUNC(_wrap_QBSpline_get_edge_cps), -1);
    rb_define_method(cQBSpline.klass, "get_segment_center", VALUEFUNC(_wrap_QBSpline_get_segment_center), -1);
    rb_define_method(cQBSpline.klass, "douglas_peucker", VALUEFUNC(_wrap_QBSpline_douglas_peucker), -1);
    rb_define_method(cQBSpline.klass, "bbox", VALUEFUNC(_wrap_QBSpline_bbox), -1);
    rb_define_method(cQBSpline.klass, "print", VALUEFUNC(_wrap_QBSpline_print), -1);
    cQBSpline.mark = 0;
    cQBSpline.destroy = (void (*)(void *)) free_QBSpline;
    
    cBezierComplex.klass = rb_define_class_under(mTumble, "BezierComplex", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t, (void *) &cBezierComplex);
    rb_define_alloc_func(cBezierComplex.klass, _wrap_BezierComplex_allocate);
    rb_define_method(cBezierComplex.klass, "initialize", VALUEFUNC(_wrap_new_BezierComplex), -1);
    rb_define_method(cBezierComplex.klass, "import_mesh", VALUEFUNC(_wrap_BezierComplex_import_mesh), -1);
    rb_define_method(cBezierComplex.klass, "add_cp", VALUEFUNC(_wrap_BezierComplex_add_cp), -1);
    rb_define_method(cBezierComplex.klass, "rem_cp", VALUEFUNC(_wrap_BezierComplex_rem_cp), -1);
    rb_define_method(cBezierComplex.klass, "add_dp", VALUEFUNC(_wrap_BezierComplex_add_dp), -1);
    rb_define_method(cBezierComplex.klass, "rem_dp", VALUEFUNC(_wrap_BezierComplex_rem_dp), -1);
    rb_define_method(cBezierComplex.klass, "add_vertex", VALUEFUNC(_wrap_BezierComplex_add_vertex), -1);
    rb_define_method(cBezierComplex.klass, "add_edge", VALUEFUNC(_wrap_BezierComplex_add_edge), -1);
    rb_define_method(cBezierComplex.klass, "add_face", VALUEFUNC(_wrap_BezierComplex_add_face), -1);
    rb_define_method(cBezierComplex.klass, "delete_vertex", VALUEFUNC(_wrap_BezierComplex_delete_vertex), -1);
    rb_define_method(cBezierComplex.klass, "delete_edge", VALUEFUNC(_wrap_BezierComplex_delete_edge), -1);
    rb_define_method(cBezierComplex.klass, "delete_face", VALUEFUNC(_wrap_BezierComplex_delete_face), -1);
    rb_define_method(cBezierComplex.klass, "is_member", VALUEFUNC(_wrap_BezierComplex_is_member), -1);
    rb_define_method(cBezierComplex.klass, "lower", VALUEFUNC(_wrap_BezierComplex_lower), -1);
    rb_define_method(cBezierComplex.klass, "upper", VALUEFUNC(_wrap_BezierComplex_upper), -1);
    rb_define_method(cBezierComplex.klass, "get_opposite_vertex", VALUEFUNC(_wrap_BezierComplex_get_opposite_vertex), -1);
    rb_define_method(cBezierComplex.klass, "get_opposite_face", VALUEFUNC(_wrap_BezierComplex_get_opposite_face), -1);
    rb_define_method(cBezierComplex.klass, "enqueue_faces", VALUEFUNC(_wrap_BezierComplex_enqueue_faces), -1);
    rb_define_method(cBezierComplex.klass, "enqueue_edges", VALUEFUNC(_wrap_BezierComplex_enqueue_edges), -1);
    rb_define_method(cBezierComplex.klass, "find_common_edge", VALUEFUNC(_wrap_BezierComplex_find_common_edge), -1);
    rb_define_method(cBezierComplex.klass, "find_adjacent_faces", VALUEFUNC(_wrap_BezierComplex_find_adjacent_faces), -1);
    rb_define_method(cBezierComplex.klass, "find_adjacent_edges", VALUEFUNC(_wrap_BezierComplex_find_adjacent_edges), -1);
    rb_define_method(cBezierComplex.klass, "Switch", VALUEFUNC(_wrap_BezierComplex_Switch), -1);
    rb_define_method(cBezierComplex.klass, "get_tuple", VALUEFUNC(_wrap_BezierComplex_get_tuple), -1);
    rb_define_method(cBezierComplex.klass, "is_ccw_tuple", VALUEFUNC(_wrap_BezierComplex_is_ccw_tuple), -1);
    rb_define_method(cBezierComplex.klass, "is_inverted", VALUEFUNC(_wrap_BezierComplex_is_inverted), -1);
    rb_define_method(cBezierComplex.klass, "print", VALUEFUNC(_wrap_BezierComplex_print), -1);
    rb_define_method(cBezierComplex.klass, "print_statistics", VALUEFUNC(_wrap_BezierComplex_print_statistics), -1);
    rb_define_method(cBezierComplex.klass, "num_vertexs=", VALUEFUNC(_wrap_BezierComplex_num_vertexs_set), -1);
    rb_define_method(cBezierComplex.klass, "num_vertexs", VALUEFUNC(_wrap_BezierComplex_num_vertexs_get), -1);
    rb_define_method(cBezierComplex.klass, "num_edges=", VALUEFUNC(_wrap_BezierComplex_num_edges_set), -1);
    rb_define_method(cBezierComplex.klass, "num_edges", VALUEFUNC(_wrap_BezierComplex_num_edges_get), -1);
    rb_define_method(cBezierComplex.klass, "num_faces=", VALUEFUNC(_wrap_BezierComplex_num_faces_set), -1);
    rb_define_method(cBezierComplex.klass, "num_faces", VALUEFUNC(_wrap_BezierComplex_num_faces_get), -1);
    rb_define_method(cBezierComplex.klass, "control_points=", VALUEFUNC(_wrap_BezierComplex_control_points_set), -1);
    rb_define_method(cBezierComplex.klass, "control_points", VALUEFUNC(_wrap_BezierComplex_control_points_get), -1);
    rb_define_method(cBezierComplex.klass, "data_points=", VALUEFUNC(_wrap_BezierComplex_data_points_set), -1);
    rb_define_method(cBezierComplex.klass, "data_points", VALUEFUNC(_wrap_BezierComplex_data_points_get), -1);
    rb_define_method(cBezierComplex.klass, "data_hash=", VALUEFUNC(_wrap_BezierComplex_data_hash_set), -1);
    rb_define_method(cBezierComplex.klass, "data_hash", VALUEFUNC(_wrap_BezierComplex_data_hash_get), -1);
    rb_define_method(cBezierComplex.klass, "vertexs=", VALUEFUNC(_wrap_BezierComplex_vertexs_set), -1);
    rb_define_method(cBezierComplex.klass, "vertexs", VALUEFUNC(_wrap_BezierComplex_vertexs_get), -1);
    rb_define_method(cBezierComplex.klass, "edges=", VALUEFUNC(_wrap_BezierComplex_edges_set), -1);
    rb_define_method(cBezierComplex.klass, "edges", VALUEFUNC(_wrap_BezierComplex_edges_get), -1);
    rb_define_method(cBezierComplex.klass, "faces=", VALUEFUNC(_wrap_BezierComplex_faces_set), -1);
    rb_define_method(cBezierComplex.klass, "faces", VALUEFUNC(_wrap_BezierComplex_faces_get), -1);
    cBezierComplex.mark = 0;
    cBezierComplex.destroy = (void (*)(void *)) free_CellComplexlBezierVertexcBezierEdgecBezierTrianglecBezierTuple_g___;
    
    cBoundaryComplex.klass = rb_define_class_under(mTumble, "BoundaryComplex", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t, (void *) &cBoundaryComplex);
    rb_define_alloc_func(cBoundaryComplex.klass, _wrap_BoundaryComplex_allocate);
    rb_define_method(cBoundaryComplex.klass, "initialize", VALUEFUNC(_wrap_new_BoundaryComplex), -1);
    rb_define_method(cBoundaryComplex.klass, "import_mesh", VALUEFUNC(_wrap_BoundaryComplex_import_mesh), -1);
    rb_define_method(cBoundaryComplex.klass, "add_cp", VALUEFUNC(_wrap_BoundaryComplex_add_cp), -1);
    rb_define_method(cBoundaryComplex.klass, "rem_cp", VALUEFUNC(_wrap_BoundaryComplex_rem_cp), -1);
    rb_define_method(cBoundaryComplex.klass, "add_dp", VALUEFUNC(_wrap_BoundaryComplex_add_dp), -1);
    rb_define_method(cBoundaryComplex.klass, "rem_dp", VALUEFUNC(_wrap_BoundaryComplex_rem_dp), -1);
    rb_define_method(cBoundaryComplex.klass, "add_vertex", VALUEFUNC(_wrap_BoundaryComplex_add_vertex), -1);
    rb_define_method(cBoundaryComplex.klass, "add_edge", VALUEFUNC(_wrap_BoundaryComplex_add_edge), -1);
    rb_define_method(cBoundaryComplex.klass, "add_face", VALUEFUNC(_wrap_BoundaryComplex_add_face), -1);
    rb_define_method(cBoundaryComplex.klass, "delete_vertex", VALUEFUNC(_wrap_BoundaryComplex_delete_vertex), -1);
    rb_define_method(cBoundaryComplex.klass, "delete_edge", VALUEFUNC(_wrap_BoundaryComplex_delete_edge), -1);
    rb_define_method(cBoundaryComplex.klass, "delete_face", VALUEFUNC(_wrap_BoundaryComplex_delete_face), -1);
    rb_define_method(cBoundaryComplex.klass, "is_member", VALUEFUNC(_wrap_BoundaryComplex_is_member), -1);
    rb_define_method(cBoundaryComplex.klass, "lower", VALUEFUNC(_wrap_BoundaryComplex_lower), -1);
    rb_define_method(cBoundaryComplex.klass, "upper", VALUEFUNC(_wrap_BoundaryComplex_upper), -1);
    rb_define_method(cBoundaryComplex.klass, "get_opposite_vertex", VALUEFUNC(_wrap_BoundaryComplex_get_opposite_vertex), -1);
    rb_define_method(cBoundaryComplex.klass, "get_opposite_face", VALUEFUNC(_wrap_BoundaryComplex_get_opposite_face), -1);
    rb_define_method(cBoundaryComplex.klass, "enqueue_faces", VALUEFUNC(_wrap_BoundaryComplex_enqueue_faces), -1);
    rb_define_method(cBoundaryComplex.klass, "enqueue_edges", VALUEFUNC(_wrap_BoundaryComplex_enqueue_edges), -1);
    rb_define_method(cBoundaryComplex.klass, "find_common_edge", VALUEFUNC(_wrap_BoundaryComplex_find_common_edge), -1);
    rb_define_method(cBoundaryComplex.klass, "find_adjacent_faces", VALUEFUNC(_wrap_BoundaryComplex_find_adjacent_faces), -1);
    rb_define_method(cBoundaryComplex.klass, "find_adjacent_edges", VALUEFUNC(_wrap_BoundaryComplex_find_adjacent_edges), -1);
    rb_define_method(cBoundaryComplex.klass, "Switch", VALUEFUNC(_wrap_BoundaryComplex_Switch), -1);
    rb_define_method(cBoundaryComplex.klass, "get_tuple", VALUEFUNC(_wrap_BoundaryComplex_get_tuple), -1);
    rb_define_method(cBoundaryComplex.klass, "is_ccw_tuple", VALUEFUNC(_wrap_BoundaryComplex_is_ccw_tuple), -1);
    rb_define_method(cBoundaryComplex.klass, "is_inverted", VALUEFUNC(_wrap_BoundaryComplex_is_inverted), -1);
    rb_define_method(cBoundaryComplex.klass, "print", VALUEFUNC(_wrap_BoundaryComplex_print), -1);
    rb_define_method(cBoundaryComplex.klass, "print_statistics", VALUEFUNC(_wrap_BoundaryComplex_print_statistics), -1);
    rb_define_method(cBoundaryComplex.klass, "num_vertexs=", VALUEFUNC(_wrap_BoundaryComplex_num_vertexs_set), -1);
    rb_define_method(cBoundaryComplex.klass, "num_vertexs", VALUEFUNC(_wrap_BoundaryComplex_num_vertexs_get), -1);
    rb_define_method(cBoundaryComplex.klass, "num_edges=", VALUEFUNC(_wrap_BoundaryComplex_num_edges_set), -1);
    rb_define_method(cBoundaryComplex.klass, "num_edges", VALUEFUNC(_wrap_BoundaryComplex_num_edges_get), -1);
    rb_define_method(cBoundaryComplex.klass, "num_faces=", VALUEFUNC(_wrap_BoundaryComplex_num_faces_set), -1);
    rb_define_method(cBoundaryComplex.klass, "num_faces", VALUEFUNC(_wrap_BoundaryComplex_num_faces_get), -1);
    rb_define_method(cBoundaryComplex.klass, "control_points=", VALUEFUNC(_wrap_BoundaryComplex_control_points_set), -1);
    rb_define_method(cBoundaryComplex.klass, "control_points", VALUEFUNC(_wrap_BoundaryComplex_control_points_get), -1);
    rb_define_method(cBoundaryComplex.klass, "data_points=", VALUEFUNC(_wrap_BoundaryComplex_data_points_set), -1);
    rb_define_method(cBoundaryComplex.klass, "data_points", VALUEFUNC(_wrap_BoundaryComplex_data_points_get), -1);
    rb_define_method(cBoundaryComplex.klass, "data_hash=", VALUEFUNC(_wrap_BoundaryComplex_data_hash_set), -1);
    rb_define_method(cBoundaryComplex.klass, "data_hash", VALUEFUNC(_wrap_BoundaryComplex_data_hash_get), -1);
    rb_define_method(cBoundaryComplex.klass, "vertexs=", VALUEFUNC(_wrap_BoundaryComplex_vertexs_set), -1);
    rb_define_method(cBoundaryComplex.klass, "vertexs", VALUEFUNC(_wrap_BoundaryComplex_vertexs_get), -1);
    rb_define_method(cBoundaryComplex.klass, "edges=", VALUEFUNC(_wrap_BoundaryComplex_edges_set), -1);
    rb_define_method(cBoundaryComplex.klass, "edges", VALUEFUNC(_wrap_BoundaryComplex_edges_get), -1);
    rb_define_method(cBoundaryComplex.klass, "faces=", VALUEFUNC(_wrap_BoundaryComplex_faces_set), -1);
    rb_define_method(cBoundaryComplex.klass, "faces", VALUEFUNC(_wrap_BoundaryComplex_faces_get), -1);
    cBoundaryComplex.mark = 0;
    cBoundaryComplex.destroy = (void (*)(void *)) free_CellComplexlBoundaryVertexcBoundaryEdgecBoundaryFacecBoundaryTuple_g___;
    
    cBoundaryMesh.klass = rb_define_class_under(mTumble, "BoundaryMesh", ((swig_class *) SWIGTYPE_p_CellComplexTBoundaryVertex_BoundaryEdge_BoundaryFace_CellTupleTBoundaryVertex_BoundaryEdge_BoundaryFace_t_t->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_BoundaryMesh, (void *) &cBoundaryMesh);
    rb_define_alloc_func(cBoundaryMesh.klass, _wrap_BoundaryMesh_allocate);
    rb_define_method(cBoundaryMesh.klass, "initialize", VALUEFUNC(_wrap_new_BoundaryMesh), -1);
    rb_define_method(cBoundaryMesh.klass, "beziermesh=", VALUEFUNC(_wrap_BoundaryMesh_beziermesh_set), -1);
    rb_define_method(cBoundaryMesh.klass, "beziermesh", VALUEFUNC(_wrap_BoundaryMesh_beziermesh_get), -1);
    rb_define_method(cBoundaryMesh.klass, "add_boundary_vertex", VALUEFUNC(_wrap_BoundaryMesh_add_boundary_vertex), -1);
    rb_define_method(cBoundaryMesh.klass, "add_boundary_edge", VALUEFUNC(_wrap_BoundaryMesh_add_boundary_edge), -1);
    rb_define_method(cBoundaryMesh.klass, "add_boundary_face", VALUEFUNC(_wrap_BoundaryMesh_add_boundary_face), -1);
    rb_define_method(cBoundaryMesh.klass, "bbox", VALUEFUNC(_wrap_BoundaryMesh_bbox), -1);
    cBoundaryMesh.mark = 0;
    cBoundaryMesh.destroy = (void (*)(void *)) free_BoundaryMesh;
    
    cBezierMesh.klass = rb_define_class_under(mTumble, "BezierMesh", ((swig_class *) SWIGTYPE_p_CellComplexTBezierVertex_BezierEdge_BezierTriangle_CellTupleTBezierVertex_BezierEdge_BezierTriangle_t_t->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_BezierMesh, (void *) &cBezierMesh);
    rb_define_alloc_func(cBezierMesh.klass, _wrap_BezierMesh_allocate);
    rb_define_method(cBezierMesh.klass, "initialize", VALUEFUNC(_wrap_new_BezierMesh), -1);
    rb_define_method(cBezierMesh.klass, "boundarymesh=", VALUEFUNC(_wrap_BezierMesh_boundarymesh_set), -1);
    rb_define_method(cBezierMesh.klass, "boundarymesh", VALUEFUNC(_wrap_BezierMesh_boundarymesh_get), -1);
    rb_define_method(cBezierMesh.klass, "en_vertex_vector=", VALUEFUNC(_wrap_BezierMesh_en_vertex_vector_set), -1);
    rb_define_method(cBezierMesh.klass, "en_vertex_vector", VALUEFUNC(_wrap_BezierMesh_en_vertex_vector_get), -1);
    rb_define_method(cBezierMesh.klass, "en_edge_vector=", VALUEFUNC(_wrap_BezierMesh_en_edge_vector_set), -1);
    rb_define_method(cBezierMesh.klass, "en_edge_vector", VALUEFUNC(_wrap_BezierMesh_en_edge_vector_get), -1);
    rb_define_method(cBezierMesh.klass, "en_face_vector=", VALUEFUNC(_wrap_BezierMesh_en_face_vector_set), -1);
    rb_define_method(cBezierMesh.klass, "en_face_vector", VALUEFUNC(_wrap_BezierMesh_en_face_vector_get), -1);
    rb_define_method(cBezierMesh.klass, "en_bedge_vector=", VALUEFUNC(_wrap_BezierMesh_en_bedge_vector_set), -1);
    rb_define_method(cBezierMesh.klass, "en_bedge_vector", VALUEFUNC(_wrap_BezierMesh_en_bedge_vector_get), -1);
    rb_define_method(cBezierMesh.klass, "set_linear_flips", VALUEFUNC(_wrap_BezierMesh_set_linear_flips), -1);
    rb_define_method(cBezierMesh.klass, "add_bezier_vertex", VALUEFUNC(_wrap_BezierMesh_add_bezier_vertex), -1);
    rb_define_method(cBezierMesh.klass, "add_bezier_edge", VALUEFUNC(_wrap_BezierMesh_add_bezier_edge), -1);
    rb_define_method(cBezierMesh.klass, "add_bezier_triangle", VALUEFUNC(_wrap_BezierMesh_add_bezier_triangle), -1);
    rb_define_method(cBezierMesh.klass, "clean_insert_point", VALUEFUNC(_wrap_BezierMesh_clean_insert_point), -1);
    rb_define_method(cBezierMesh.klass, "clean_insert_edge_midpoint", VALUEFUNC(_wrap_BezierMesh_clean_insert_edge_midpoint), -1);
    rb_define_method(cBezierMesh.klass, "remove_vertex", VALUEFUNC(_wrap_BezierMesh_remove_vertex), -1);
    rb_define_method(cBezierMesh.klass, "smooth_edge", VALUEFUNC(_wrap_BezierMesh_smooth_edge), -1);
    rb_define_method(cBezierMesh.klass, "flip", VALUEFUNC(_wrap_BezierMesh_flip), -1);
    rb_define_method(cBezierMesh.klass, "should_flip", VALUEFUNC(_wrap_BezierMesh_should_flip), -1);
    rb_define_method(cBezierMesh.klass, "can_flip", VALUEFUNC(_wrap_BezierMesh_can_flip), -1);
    rb_define_method(cBezierMesh.klass, "can_smooth", VALUEFUNC(_wrap_BezierMesh_can_smooth), -1);
    rb_define_method(cBezierMesh.klass, "blind_locate_point", VALUEFUNC(_wrap_BezierMesh_blind_locate_point), -1);
    rb_define_method(cBezierMesh.klass, "locate_point", VALUEFUNC(_wrap_BezierMesh_locate_point), -1);
    rb_define_method(cBezierMesh.klass, "enumerate", VALUEFUNC(_wrap_BezierMesh_enumerate), -1);
    rb_define_method(cBezierMesh.klass, "en_vertex", VALUEFUNC(_wrap_BezierMesh_en_vertex), -1);
    rb_define_method(cBezierMesh.klass, "en_edge", VALUEFUNC(_wrap_BezierMesh_en_edge), -1);
    rb_define_method(cBezierMesh.klass, "en_face", VALUEFUNC(_wrap_BezierMesh_en_face), -1);
    rb_define_method(cBezierMesh.klass, "en_bedge", VALUEFUNC(_wrap_BezierMesh_en_bedge), -1);
    cBezierMesh.mark = 0;
    cBezierMesh.destroy = (void (*)(void *)) free_BezierMesh;
    
    cMeshInput.klass = rb_define_class_under(mTumble, "MeshInput", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_MeshInput, (void *) &cMeshInput);
    rb_define_alloc_func(cMeshInput.klass, _wrap_MeshInput_allocate);
    rb_define_method(cMeshInput.klass, "initialize", VALUEFUNC(_wrap_new_MeshInput), -1);
    rb_define_method(cMeshInput.klass, "read", VALUEFUNC(_wrap_MeshInput_read), -1);
    cMeshInput.mark = 0;
    cMeshInput.destroy = (void (*)(void *)) free_MeshInput;
    
    cMeshOutput.klass = rb_define_class_under(mTumble, "MeshOutput", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_MeshOutput, (void *) &cMeshOutput);
    rb_define_alloc_func(cMeshOutput.klass, _wrap_MeshOutput_allocate);
    rb_define_method(cMeshOutput.klass, "initialize", VALUEFUNC(_wrap_new_MeshOutput), -1);
    rb_define_method(cMeshOutput.klass, "write", VALUEFUNC(_wrap_MeshOutput_write), -1);
    cMeshOutput.mark = 0;
    cMeshOutput.destroy = (void (*)(void *)) free_MeshOutput;
    
    cSimulation.klass = rb_define_class_under(mTumble, "Simulation", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_Simulation, (void *) &cSimulation);
    rb_define_alloc_func(cSimulation.klass, _wrap_Simulation_allocate);
    rb_define_method(cSimulation.klass, "initialize", VALUEFUNC(_wrap_new_Simulation), -1);
    rb_define_method(cSimulation.klass, "bdry_mesh=", VALUEFUNC(_wrap_Simulation_bdry_mesh_set), -1);
    rb_define_method(cSimulation.klass, "bdry_mesh", VALUEFUNC(_wrap_Simulation_bdry_mesh_get), -1);
    rb_define_method(cSimulation.klass, "bezier_mesh=", VALUEFUNC(_wrap_Simulation_bezier_mesh_set), -1);
    rb_define_method(cSimulation.klass, "bezier_mesh", VALUEFUNC(_wrap_Simulation_bezier_mesh_get), -1);
    rb_define_method(cSimulation.klass, "timekeeper=", VALUEFUNC(_wrap_Simulation_timekeeper_set), -1);
    rb_define_method(cSimulation.klass, "timekeeper", VALUEFUNC(_wrap_Simulation_timekeeper_get), -1);
    rb_define_method(cSimulation.klass, "get_bezier_mesh", VALUEFUNC(_wrap_Simulation_get_bezier_mesh), -1);
    rb_define_method(cSimulation.klass, "get_boundary_mesh", VALUEFUNC(_wrap_Simulation_get_boundary_mesh), -1);
    rb_define_method(cSimulation.klass, "move", VALUEFUNC(_wrap_Simulation_move), -1);
    rb_define_method(cSimulation.klass, "clean", VALUEFUNC(_wrap_Simulation_clean), -1);
    rb_define_method(cSimulation.klass, "to_file", VALUEFUNC(_wrap_Simulation_to_file), -1);
    rb_define_method(cSimulation.klass, "to_eps", VALUEFUNC(_wrap_Simulation_to_eps), -1);
    rb_define_method(cSimulation.klass, "start_logging", VALUEFUNC(_wrap_Simulation_start_logging), -1);
    rb_define_method(cSimulation.klass, "print", VALUEFUNC(_wrap_Simulation_print), -1);
    rb_define_method(cSimulation.klass, "print_statistics", VALUEFUNC(_wrap_Simulation_print_statistics), -1);
    rb_define_method(cSimulation.klass, "print_times", VALUEFUNC(_wrap_Simulation_print_times), -1);
    cSimulation.mark = 0;
    cSimulation.destroy = (void (*)(void *)) free_Simulation;
    rb_define_const(mTumble,"EDGE_DRW_ACC", INT2NUM(8));
    rb_define_const(mTumble,"FACE_DRW_ACC", INT2NUM(8));
    
    cVisualization.klass = rb_define_class_under(mTumble, "Visualization", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_Visualization, (void *) &cVisualization);
    rb_define_alloc_func(cVisualization.klass, _wrap_Visualization_allocate);
    rb_define_method(cVisualization.klass, "initialize", VALUEFUNC(_wrap_new_Visualization), -1);
    rb_define_method(cVisualization.klass, "world_top=", VALUEFUNC(_wrap_Visualization_world_top_set), -1);
    rb_define_method(cVisualization.klass, "world_top", VALUEFUNC(_wrap_Visualization_world_top_get), -1);
    rb_define_method(cVisualization.klass, "world_bot=", VALUEFUNC(_wrap_Visualization_world_bot_set), -1);
    rb_define_method(cVisualization.klass, "world_bot", VALUEFUNC(_wrap_Visualization_world_bot_get), -1);
    rb_define_method(cVisualization.klass, "world_center=", VALUEFUNC(_wrap_Visualization_world_center_set), -1);
    rb_define_method(cVisualization.klass, "world_center", VALUEFUNC(_wrap_Visualization_world_center_get), -1);
    rb_define_method(cVisualization.klass, "world_width=", VALUEFUNC(_wrap_Visualization_world_width_set), -1);
    rb_define_method(cVisualization.klass, "world_width", VALUEFUNC(_wrap_Visualization_world_width_get), -1);
    rb_define_method(cVisualization.klass, "world_height=", VALUEFUNC(_wrap_Visualization_world_height_set), -1);
    rb_define_method(cVisualization.klass, "world_height", VALUEFUNC(_wrap_Visualization_world_height_get), -1);
    rb_define_method(cVisualization.klass, "world_ratio=", VALUEFUNC(_wrap_Visualization_world_ratio_set), -1);
    rb_define_method(cVisualization.klass, "world_ratio", VALUEFUNC(_wrap_Visualization_world_ratio_get), -1);
    rb_define_method(cVisualization.klass, "zoom_top=", VALUEFUNC(_wrap_Visualization_zoom_top_set), -1);
    rb_define_method(cVisualization.klass, "zoom_top", VALUEFUNC(_wrap_Visualization_zoom_top_get), -1);
    rb_define_method(cVisualization.klass, "zoom_bot=", VALUEFUNC(_wrap_Visualization_zoom_bot_set), -1);
    rb_define_method(cVisualization.klass, "zoom_bot", VALUEFUNC(_wrap_Visualization_zoom_bot_get), -1);
    rb_define_method(cVisualization.klass, "zoom_center=", VALUEFUNC(_wrap_Visualization_zoom_center_set), -1);
    rb_define_method(cVisualization.klass, "zoom_center", VALUEFUNC(_wrap_Visualization_zoom_center_get), -1);
    rb_define_method(cVisualization.klass, "zoom_width=", VALUEFUNC(_wrap_Visualization_zoom_width_set), -1);
    rb_define_method(cVisualization.klass, "zoom_width", VALUEFUNC(_wrap_Visualization_zoom_width_get), -1);
    rb_define_method(cVisualization.klass, "zoom_height=", VALUEFUNC(_wrap_Visualization_zoom_height_set), -1);
    rb_define_method(cVisualization.klass, "zoom_height", VALUEFUNC(_wrap_Visualization_zoom_height_get), -1);
    rb_define_method(cVisualization.klass, "zoom_ratio=", VALUEFUNC(_wrap_Visualization_zoom_ratio_set), -1);
    rb_define_method(cVisualization.klass, "zoom_ratio", VALUEFUNC(_wrap_Visualization_zoom_ratio_get), -1);
    rb_define_method(cVisualization.klass, "zoomed=", VALUEFUNC(_wrap_Visualization_zoomed_set), -1);
    rb_define_method(cVisualization.klass, "zoomed", VALUEFUNC(_wrap_Visualization_zoomed_get), -1);
    rb_define_method(cVisualization.klass, "view_top=", VALUEFUNC(_wrap_Visualization_view_top_set), -1);
    rb_define_method(cVisualization.klass, "view_top", VALUEFUNC(_wrap_Visualization_view_top_get), -1);
    rb_define_method(cVisualization.klass, "view_bot=", VALUEFUNC(_wrap_Visualization_view_bot_set), -1);
    rb_define_method(cVisualization.klass, "view_bot", VALUEFUNC(_wrap_Visualization_view_bot_get), -1);
    rb_define_method(cVisualization.klass, "screen_width=", VALUEFUNC(_wrap_Visualization_screen_width_set), -1);
    rb_define_method(cVisualization.klass, "screen_width", VALUEFUNC(_wrap_Visualization_screen_width_get), -1);
    rb_define_method(cVisualization.klass, "screen_height=", VALUEFUNC(_wrap_Visualization_screen_height_set), -1);
    rb_define_method(cVisualization.klass, "screen_height", VALUEFUNC(_wrap_Visualization_screen_height_get), -1);
    rb_define_method(cVisualization.klass, "screen_ratio=", VALUEFUNC(_wrap_Visualization_screen_ratio_set), -1);
    rb_define_method(cVisualization.klass, "screen_ratio", VALUEFUNC(_wrap_Visualization_screen_ratio_get), -1);
    rb_define_method(cVisualization.klass, "colormap=", VALUEFUNC(_wrap_Visualization_colormap_set), -1);
    rb_define_method(cVisualization.klass, "colormap", VALUEFUNC(_wrap_Visualization_colormap_get), -1);
    rb_define_method(cVisualization.klass, "bezier_mesh=", VALUEFUNC(_wrap_Visualization_bezier_mesh_set), -1);
    rb_define_method(cVisualization.klass, "bezier_mesh", VALUEFUNC(_wrap_Visualization_bezier_mesh_get), -1);
    rb_define_method(cVisualization.klass, "bdry_mesh=", VALUEFUNC(_wrap_Visualization_bdry_mesh_set), -1);
    rb_define_method(cVisualization.klass, "bdry_mesh", VALUEFUNC(_wrap_Visualization_bdry_mesh_get), -1);
    rb_define_method(cVisualization.klass, "load_color_map", VALUEFUNC(_wrap_Visualization_load_color_map), -1);
    rb_define_method(cVisualization.klass, "map_color", VALUEFUNC(_wrap_Visualization_map_color), -1);
    rb_define_method(cVisualization.klass, "write_jpeg", VALUEFUNC(_wrap_Visualization_write_jpeg), -1);
    rb_define_method(cVisualization.klass, "write_tiff", VALUEFUNC(_wrap_Visualization_write_tiff), -1);
    rb_define_method(cVisualization.klass, "write_ppm", VALUEFUNC(_wrap_Visualization_write_ppm), -1);
    rb_define_method(cVisualization.klass, "resize", VALUEFUNC(_wrap_Visualization_resize), -1);
    rb_define_method(cVisualization.klass, "compute_world_size", VALUEFUNC(_wrap_Visualization_compute_world_size), -1);
    rb_define_method(cVisualization.klass, "project", VALUEFUNC(_wrap_Visualization_project), -1);
    rb_define_method(cVisualization.klass, "convert_from_screen_coords", VALUEFUNC(_wrap_Visualization_convert_from_screen_coords), -1);
    rb_define_method(cVisualization.klass, "zoomin", VALUEFUNC(_wrap_Visualization_zoomin), -1);
    rb_define_method(cVisualization.klass, "zoomout", VALUEFUNC(_wrap_Visualization_zoomout), -1);
    rb_define_method(cVisualization.klass, "draw", VALUEFUNC(_wrap_Visualization_draw), -1);
    rb_define_method(cVisualization.klass, "draw_bezier", VALUEFUNC(_wrap_Visualization_draw_bezier), -1);
    rb_define_method(cVisualization.klass, "draw_solid", VALUEFUNC(_wrap_Visualization_draw_solid), -1);
    rb_define_method(cVisualization.klass, "draw_data", VALUEFUNC(_wrap_Visualization_draw_data), -1);
    rb_define_method(cVisualization.klass, "draw_debug", VALUEFUNC(_wrap_Visualization_draw_debug), -1);
    rb_define_method(cVisualization.klass, "draw_bdry_debug", VALUEFUNC(_wrap_Visualization_draw_bdry_debug), -1);
    rb_define_method(cVisualization.klass, "draw_tuple", VALUEFUNC(_wrap_Visualization_draw_tuple), -1);
    rb_define_method(cVisualization.klass, "draw_point", VALUEFUNC(_wrap_Visualization_draw_point), -1);
    rb_define_method(cVisualization.klass, "draw_boundary_vertex", VALUEFUNC(_wrap_Visualization_draw_boundary_vertex), -1);
    rb_define_method(cVisualization.klass, "draw_boundary_edge", VALUEFUNC(_wrap_Visualization_draw_boundary_edge), -1);
    rb_define_method(cVisualization.klass, "draw_boundary_edge_debug", VALUEFUNC(_wrap_Visualization_draw_boundary_edge_debug), -1);
    rb_define_method(cVisualization.klass, "draw_bezier_vertex", VALUEFUNC(_wrap_Visualization_draw_bezier_vertex), -1);
    rb_define_method(cVisualization.klass, "draw_bezier_edge", VALUEFUNC(_wrap_Visualization_draw_bezier_edge), -1);
    rb_define_method(cVisualization.klass, "draw_bezier_triangle", VALUEFUNC(_wrap_Visualization_draw_bezier_triangle), -1);
    rb_define_method(cVisualization.klass, "draw_control_net", VALUEFUNC(_wrap_Visualization_draw_control_net), -1);
    rb_define_method(cVisualization.klass, "draw_polygon", VALUEFUNC(_wrap_Visualization_draw_polygon), -1);
    rb_define_method(cVisualization.klass, "draw_smooth_debug", VALUEFUNC(_wrap_Visualization_draw_smooth_debug), -1);
    rb_define_method(cVisualization.klass, "draw_flip_debug", VALUEFUNC(_wrap_Visualization_draw_flip_debug), -1);
    rb_define_method(cVisualization.klass, "start_draw", VALUEFUNC(_wrap_Visualization_start_draw), -1);
    rb_define_method(cVisualization.klass, "finish_draw", VALUEFUNC(_wrap_Visualization_finish_draw), -1);
    rb_define_method(cVisualization.klass, "is_visible", VALUEFUNC(_wrap_Visualization_is_visible), -1);
    rb_define_method(cVisualization.klass, "visual_locate", VALUEFUNC(_wrap_Visualization_visual_locate), -1);
    rb_define_method(cVisualization.klass, "visual_switch", VALUEFUNC(_wrap_Visualization_visual_switch), -1);
    cVisualization.mark = 0;
    cVisualization.destroy = (void (*)(void *)) free_Visualization;
    
    cColor.klass = rb_define_class_under(mTumble, "Color", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_Color, (void *) &cColor);
    rb_define_alloc_func(cColor.klass, _wrap_Color_allocate);
    rb_define_method(cColor.klass, "initialize", VALUEFUNC(_wrap_new_Color), -1);
    rb_define_method(cColor.klass, "v=", VALUEFUNC(_wrap_Color_v_set), -1);
    rb_define_method(cColor.klass, "v", VALUEFUNC(_wrap_Color_v_get), -1);
    rb_define_method(cColor.klass, "assign", VALUEFUNC(_wrap_Color_assign), -1);
    rb_define_method(cColor.klass, "R", VALUEFUNC(_wrap_Color_R), -1);
    rb_define_method(cColor.klass, "G", VALUEFUNC(_wrap_Color_G), -1);
    rb_define_method(cColor.klass, "B", VALUEFUNC(_wrap_Color_B), -1);
    rb_define_method(cColor.klass, "is_valid", VALUEFUNC(_wrap_Color_is_valid), -1);
    cColor.mark = 0;
    cColor.destroy = (void (*)(void *)) free_Color;
    rb_define_module_function(mTumble, "default_opengl_color_map", VALUEFUNC(_wrap_default_opengl_color_map), -1);
    rb_define_module_function(mTumble, "default_eps_rgb_map", VALUEFUNC(_wrap_default_eps_rgb_map), -1);
    rb_define_module_function(mTumble, "default_eps_grayscale_map", VALUEFUNC(_wrap_default_eps_grayscale_map), -1);
    rb_define_module_function(mTumble, "load_map", VALUEFUNC(_wrap_load_map), -1);
    rb_define_const(mTumble,"DRAW_OFF", INT2NUM(0));
    rb_define_const(mTumble,"DRAW_GRAYSCALE", INT2NUM(1));
    rb_define_const(mTumble,"DRAW_RGB", INT2NUM(2));
    
    cPSCoord.klass = rb_define_class_under(mTumble, "PSCoord", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_PSCoord, (void *) &cPSCoord);
    rb_define_alloc_func(cPSCoord.klass, _wrap_PSCoord_allocate);
    rb_define_method(cPSCoord.klass, "initialize", VALUEFUNC(_wrap_new_PSCoord), -1);
    rb_define_method(cPSCoord.klass, "x=", VALUEFUNC(_wrap_PSCoord_x_set), -1);
    rb_define_method(cPSCoord.klass, "x", VALUEFUNC(_wrap_PSCoord_x_get), -1);
    rb_define_method(cPSCoord.klass, "y=", VALUEFUNC(_wrap_PSCoord_y_set), -1);
    rb_define_method(cPSCoord.klass, "y", VALUEFUNC(_wrap_PSCoord_y_get), -1);
    cPSCoord.mark = 0;
    cPSCoord.destroy = (void (*)(void *)) free_PSCoord;
    
    cPSDrawMode.klass = rb_define_class_under(mTumble, "PSDrawMode", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_PSDrawMode, (void *) &cPSDrawMode);
    rb_define_alloc_func(cPSDrawMode.klass, _wrap_PSDrawMode_allocate);
    rb_define_method(cPSDrawMode.klass, "initialize", VALUEFUNC(_wrap_new_PSDrawMode), -1);
    rb_define_method(cPSDrawMode.klass, "mode=", VALUEFUNC(_wrap_PSDrawMode_mode_set), -1);
    rb_define_method(cPSDrawMode.klass, "mode", VALUEFUNC(_wrap_PSDrawMode_mode_get), -1);
    rb_define_method(cPSDrawMode.klass, "linewidth=", VALUEFUNC(_wrap_PSDrawMode_linewidth_set), -1);
    rb_define_method(cPSDrawMode.klass, "linewidth", VALUEFUNC(_wrap_PSDrawMode_linewidth_get), -1);
    rb_define_method(cPSDrawMode.klass, "grayscale=", VALUEFUNC(_wrap_PSDrawMode_grayscale_set), -1);
    rb_define_method(cPSDrawMode.klass, "grayscale", VALUEFUNC(_wrap_PSDrawMode_grayscale_get), -1);
    rb_define_method(cPSDrawMode.klass, "rgbcolor=", VALUEFUNC(_wrap_PSDrawMode_rgbcolor_set), -1);
    rb_define_method(cPSDrawMode.klass, "rgbcolor", VALUEFUNC(_wrap_PSDrawMode_rgbcolor_get), -1);
    cPSDrawMode.mark = 0;
    cPSDrawMode.destroy = (void (*)(void *)) free_PSDrawMode;
    
    cEPSWrite.klass = rb_define_class_under(mTumble, "EPSWrite", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_EPSWrite, (void *) &cEPSWrite);
    rb_define_alloc_func(cEPSWrite.klass, _wrap_EPSWrite_allocate);
    rb_define_method(cEPSWrite.klass, "initialize", VALUEFUNC(_wrap_new_EPSWrite), -1);
    rb_define_method(cEPSWrite.klass, "load_rgb_map", VALUEFUNC(_wrap_EPSWrite_load_rgb_map), -1);
    rb_define_method(cEPSWrite.klass, "load_grayscale_map", VALUEFUNC(_wrap_EPSWrite_load_grayscale_map), -1);
    rb_define_method(cEPSWrite.klass, "map_rgbcolor", VALUEFUNC(_wrap_EPSWrite_map_rgbcolor), -1);
    rb_define_method(cEPSWrite.klass, "map_grayscale", VALUEFUNC(_wrap_EPSWrite_map_grayscale), -1);
    rb_define_method(cEPSWrite.klass, "set_border_draw", VALUEFUNC(_wrap_EPSWrite_set_border_draw), -1);
    rb_define_method(cEPSWrite.klass, "set_border_ink", VALUEFUNC(_wrap_EPSWrite_set_border_ink), -1);
    rb_define_method(cEPSWrite.klass, "set_edge_draw", VALUEFUNC(_wrap_EPSWrite_set_edge_draw), -1);
    rb_define_method(cEPSWrite.klass, "set_edge_ink", VALUEFUNC(_wrap_EPSWrite_set_edge_ink), -1);
    rb_define_method(cEPSWrite.klass, "set_bdry_draw", VALUEFUNC(_wrap_EPSWrite_set_bdry_draw), -1);
    rb_define_method(cEPSWrite.klass, "set_bdry_ink", VALUEFUNC(_wrap_EPSWrite_set_bdry_ink), -1);
    rb_define_method(cEPSWrite.klass, "set_face_draw", VALUEFUNC(_wrap_EPSWrite_set_face_draw), -1);
    rb_define_method(cEPSWrite.klass, "set_page_dim", VALUEFUNC(_wrap_EPSWrite_set_page_dim), -1);
    rb_define_method(cEPSWrite.klass, "set_page_dim_inch", VALUEFUNC(_wrap_EPSWrite_set_page_dim_inch), -1);
    rb_define_method(cEPSWrite.klass, "set_world_view", VALUEFUNC(_wrap_EPSWrite_set_world_view), -1);
    rb_define_method(cEPSWrite.klass, "write", VALUEFUNC(_wrap_EPSWrite_write), -1);
    cEPSWrite.mark = 0;
    cEPSWrite.destroy = (void (*)(void *)) free_EPSWrite;
    
    cMeshConstructor.klass = rb_define_class_under(mTumble, "MeshConstructor", rb_cObject);
    SWIG_TypeClientData(SWIGTYPE_p_MeshConstructor, (void *) &cMeshConstructor);
    rb_define_alloc_func(cMeshConstructor.klass, _wrap_MeshConstructor_allocate);
    rb_define_method(cMeshConstructor.klass, "initialize", VALUEFUNC(_wrap_new_MeshConstructor), -1);
    rb_define_method(cMeshConstructor.klass, "make_simulation", VALUEFUNC(_wrap_MeshConstructor_make_simulation), -1);
    cMeshConstructor.mark = 0;
    cMeshConstructor.destroy = (void (*)(void *)) free_MeshConstructor;
    rb_define_const(mTumble,"PUMP_OUTER_EDGE", INT2NUM(0));
    rb_define_const(mTumble,"PUMP_PROP_EDGE", INT2NUM(1));
    rb_define_const(mTumble,"PUMP_INLET_EDGE", INT2NUM(2));
    rb_define_const(mTumble,"PUMP_OUTLET_EDGE", INT2NUM(3));
    rb_define_const(mTumble,"PUMP_CELL_EDGE", INT2NUM(4));
    rb_define_const(mTumble,"PUMP_PUMP_FACE", INT2NUM(0));
    rb_define_const(mTumble,"PUMP_CELL_FACE", INT2NUM(1));
    
    cPump.klass = rb_define_class_under(mTumble, "Pump", ((swig_class *) SWIGTYPE_p_Simulation->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_Pump, (void *) &cPump);
    rb_define_alloc_func(cPump.klass, _wrap_Pump_allocate);
    rb_define_method(cPump.klass, "initialize", VALUEFUNC(_wrap_new_Pump), -1);
    rb_define_method(cPump.klass, "outer_edges=", VALUEFUNC(_wrap_Pump_outer_edges_set), -1);
    rb_define_method(cPump.klass, "outer_edges", VALUEFUNC(_wrap_Pump_outer_edges_get), -1);
    rb_define_method(cPump.klass, "propeller_edges=", VALUEFUNC(_wrap_Pump_propeller_edges_set), -1);
    rb_define_method(cPump.klass, "propeller_edges", VALUEFUNC(_wrap_Pump_propeller_edges_get), -1);
    rb_define_method(cPump.klass, "inlet_edges=", VALUEFUNC(_wrap_Pump_inlet_edges_set), -1);
    rb_define_method(cPump.klass, "inlet_edges", VALUEFUNC(_wrap_Pump_inlet_edges_get), -1);
    rb_define_method(cPump.klass, "outlet_edge=", VALUEFUNC(_wrap_Pump_outlet_edge_set), -1);
    rb_define_method(cPump.klass, "outlet_edge", VALUEFUNC(_wrap_Pump_outlet_edge_get), -1);
    rb_define_method(cPump.klass, "pump_face=", VALUEFUNC(_wrap_Pump_pump_face_set), -1);
    rb_define_method(cPump.klass, "pump_face", VALUEFUNC(_wrap_Pump_pump_face_get), -1);
    rb_define_method(cPump.klass, "cell_edges=", VALUEFUNC(_wrap_Pump_cell_edges_set), -1);
    rb_define_method(cPump.klass, "cell_edges", VALUEFUNC(_wrap_Pump_cell_edges_get), -1);
    rb_define_method(cPump.klass, "cell_centers=", VALUEFUNC(_wrap_Pump_cell_centers_set), -1);
    rb_define_method(cPump.klass, "cell_centers", VALUEFUNC(_wrap_Pump_cell_centers_get), -1);
    rb_define_method(cPump.klass, "cell_faces=", VALUEFUNC(_wrap_Pump_cell_faces_set), -1);
    rb_define_method(cPump.klass, "cell_faces", VALUEFUNC(_wrap_Pump_cell_faces_get), -1);
    rb_define_method(cPump.klass, "center=", VALUEFUNC(_wrap_Pump_center_set), -1);
    rb_define_method(cPump.klass, "center", VALUEFUNC(_wrap_Pump_center_get), -1);
    rb_define_method(cPump.klass, "inlet_radius=", VALUEFUNC(_wrap_Pump_inlet_radius_set), -1);
    rb_define_method(cPump.klass, "inlet_radius", VALUEFUNC(_wrap_Pump_inlet_radius_get), -1);
    rb_define_method(cPump.klass, "outer_radius=", VALUEFUNC(_wrap_Pump_outer_radius_set), -1);
    rb_define_method(cPump.klass, "outer_radius", VALUEFUNC(_wrap_Pump_outer_radius_get), -1);
    rb_define_method(cPump.klass, "outlet_width=", VALUEFUNC(_wrap_Pump_outlet_width_set), -1);
    rb_define_method(cPump.klass, "outlet_width", VALUEFUNC(_wrap_Pump_outlet_width_get), -1);
    rb_define_method(cPump.klass, "outlet_length=", VALUEFUNC(_wrap_Pump_outlet_length_set), -1);
    rb_define_method(cPump.klass, "outlet_length", VALUEFUNC(_wrap_Pump_outlet_length_get), -1);
    rb_define_method(cPump.klass, "num_blades=", VALUEFUNC(_wrap_Pump_num_blades_set), -1);
    rb_define_method(cPump.klass, "num_blades", VALUEFUNC(_wrap_Pump_num_blades_get), -1);
    rb_define_method(cPump.klass, "blade_width=", VALUEFUNC(_wrap_Pump_blade_width_set), -1);
    rb_define_method(cPump.klass, "blade_width", VALUEFUNC(_wrap_Pump_blade_width_get), -1);
    rb_define_method(cPump.klass, "blade_gap=", VALUEFUNC(_wrap_Pump_blade_gap_set), -1);
    rb_define_method(cPump.klass, "blade_gap", VALUEFUNC(_wrap_Pump_blade_gap_get), -1);
    rb_define_method(cPump.klass, "velocity=", VALUEFUNC(_wrap_Pump_velocity_set), -1);
    rb_define_method(cPump.klass, "velocity", VALUEFUNC(_wrap_Pump_velocity_get), -1);
    rb_define_method(cPump.klass, "num_cells=", VALUEFUNC(_wrap_Pump_num_cells_set), -1);
    rb_define_method(cPump.klass, "num_cells", VALUEFUNC(_wrap_Pump_num_cells_get), -1);
    rb_define_method(cPump.klass, "cell_type=", VALUEFUNC(_wrap_Pump_cell_type_set), -1);
    rb_define_method(cPump.klass, "cell_type", VALUEFUNC(_wrap_Pump_cell_type_get), -1);
    rb_define_method(cPump.klass, "cell_width=", VALUEFUNC(_wrap_Pump_cell_width_set), -1);
    rb_define_method(cPump.klass, "cell_width", VALUEFUNC(_wrap_Pump_cell_width_get), -1);
    rb_define_method(cPump.klass, "cell_height=", VALUEFUNC(_wrap_Pump_cell_height_set), -1);
    rb_define_method(cPump.klass, "cell_height", VALUEFUNC(_wrap_Pump_cell_height_get), -1);
    rb_define_method(cPump.klass, "size_const=", VALUEFUNC(_wrap_Pump_size_const_set), -1);
    rb_define_method(cPump.klass, "size_const", VALUEFUNC(_wrap_Pump_size_const_get), -1);
    rb_define_method(cPump.klass, "min_angle=", VALUEFUNC(_wrap_Pump_min_angle_set), -1);
    rb_define_method(cPump.klass, "min_angle", VALUEFUNC(_wrap_Pump_min_angle_get), -1);
    rb_define_method(cPump.klass, "make_test", VALUEFUNC(_wrap_Pump_make_test), -1);
    rb_define_method(cPump.klass, "make_pump", VALUEFUNC(_wrap_Pump_make_pump), -1);
    cPump.mark = 0;
    cPump.destroy = (void (*)(void *)) free_Pump;
    rb_define_const(mTumble,"SLITCAVITY_CELL_EDGE", INT2NUM(4));
    rb_define_const(mTumble,"SLITCAVITY_FORWARD_EDGE", INT2NUM(3));
    rb_define_const(mTumble,"SLITCAVITY_REAR_EDGE", INT2NUM(2));
    rb_define_const(mTumble,"SLITCAVITY_OUTSIDE_EDGE", INT2NUM(1));
    rb_define_const(mTumble,"SLITCAVITY_CAVITY_FACE", INT2NUM(1));
    rb_define_const(mTumble,"SLITCAVITY_CELL_FACE", INT2NUM(2));
    
    cSlitCavity.klass = rb_define_class_under(mTumble, "SlitCavity", ((swig_class *) SWIGTYPE_p_Simulation->clientdata)->klass);
    SWIG_TypeClientData(SWIGTYPE_p_SlitCavity, (void *) &cSlitCavity);
    rb_define_alloc_func(cSlitCavity.klass, _wrap_SlitCavity_allocate);
    rb_define_method(cSlitCavity.klass, "initialize", VALUEFUNC(_wrap_new_SlitCavity), -1);
    rb_define_method(cSlitCavity.klass, "outer_edges=", VALUEFUNC(_wrap_SlitCavity_outer_edges_set), -1);
    rb_define_method(cSlitCavity.klass, "outer_edges", VALUEFUNC(_wrap_SlitCavity_outer_edges_get), -1);
    rb_define_method(cSlitCavity.klass, "rear_edge=", VALUEFUNC(_wrap_SlitCavity_rear_edge_set), -1);
    rb_define_method(cSlitCavity.klass, "rear_edge", VALUEFUNC(_wrap_SlitCavity_rear_edge_get), -1);
    rb_define_method(cSlitCavity.klass, "forward_edge=", VALUEFUNC(_wrap_SlitCavity_forward_edge_set), -1);
    rb_define_method(cSlitCavity.klass, "forward_edge", VALUEFUNC(_wrap_SlitCavity_forward_edge_get), -1);
    rb_define_method(cSlitCavity.klass, "cell_edges=", VALUEFUNC(_wrap_SlitCavity_cell_edges_set), -1);
    rb_define_method(cSlitCavity.klass, "cell_edges", VALUEFUNC(_wrap_SlitCavity_cell_edges_get), -1);
    rb_define_method(cSlitCavity.klass, "cell_centers=", VALUEFUNC(_wrap_SlitCavity_cell_centers_set), -1);
    rb_define_method(cSlitCavity.klass, "cell_centers", VALUEFUNC(_wrap_SlitCavity_cell_centers_get), -1);
    rb_define_method(cSlitCavity.klass, "cell_faces=", VALUEFUNC(_wrap_SlitCavity_cell_faces_set), -1);
    rb_define_method(cSlitCavity.klass, "cell_faces", VALUEFUNC(_wrap_SlitCavity_cell_faces_get), -1);
    rb_define_method(cSlitCavity.klass, "cavity=", VALUEFUNC(_wrap_SlitCavity_cavity_set), -1);
    rb_define_method(cSlitCavity.klass, "cavity", VALUEFUNC(_wrap_SlitCavity_cavity_get), -1);
    rb_define_method(cSlitCavity.klass, "min_angle=", VALUEFUNC(_wrap_SlitCavity_min_angle_set), -1);
    rb_define_method(cSlitCavity.klass, "min_angle", VALUEFUNC(_wrap_SlitCavity_min_angle_get), -1);
    rb_define_method(cSlitCavity.klass, "num_cells=", VALUEFUNC(_wrap_SlitCavity_num_cells_set), -1);
    rb_define_method(cSlitCavity.klass, "num_cells", VALUEFUNC(_wrap_SlitCavity_num_cells_get), -1);
    rb_define_method(cSlitCavity.klass, "cell_type=", VALUEFUNC(_wrap_SlitCavity_cell_type_set), -1);
    rb_define_method(cSlitCavity.klass, "cell_type", VALUEFUNC(_wrap_SlitCavity_cell_type_get), -1);
    rb_define_method(cSlitCavity.klass, "cell_width=", VALUEFUNC(_wrap_SlitCavity_cell_width_set), -1);
    rb_define_method(cSlitCavity.klass, "cell_width", VALUEFUNC(_wrap_SlitCavity_cell_width_get), -1);
    rb_define_method(cSlitCavity.klass, "cell_height=", VALUEFUNC(_wrap_SlitCavity_cell_height_set), -1);
    rb_define_method(cSlitCavity.klass, "cell_height", VALUEFUNC(_wrap_SlitCavity_cell_height_get), -1);
    rb_define_method(cSlitCavity.klass, "slit_height=", VALUEFUNC(_wrap_SlitCavity_slit_height_set), -1);
    rb_define_method(cSlitCavity.klass, "slit_height", VALUEFUNC(_wrap_SlitCavity_slit_height_get), -1);
    rb_define_method(cSlitCavity.klass, "slit_length=", VALUEFUNC(_wrap_SlitCavity_slit_length_set), -1);
    rb_define_method(cSlitCavity.klass, "slit_length", VALUEFUNC(_wrap_SlitCavity_slit_length_get), -1);
    rb_define_method(cSlitCavity.klass, "cavity_height=", VALUEFUNC(_wrap_SlitCavity_cavity_height_set), -1);
    rb_define_method(cSlitCavity.klass, "cavity_height", VALUEFUNC(_wrap_SlitCavity_cavity_height_get), -1);
    rb_define_method(cSlitCavity.klass, "inlet_length=", VALUEFUNC(_wrap_SlitCavity_inlet_length_set), -1);
    rb_define_method(cSlitCavity.klass, "inlet_length", VALUEFUNC(_wrap_SlitCavity_inlet_length_get), -1);
    rb_define_method(cSlitCavity.klass, "outlet_length=", VALUEFUNC(_wrap_SlitCavity_outlet_length_set), -1);
    rb_define_method(cSlitCavity.klass, "outlet_length", VALUEFUNC(_wrap_SlitCavity_outlet_length_get), -1);
    rb_define_method(cSlitCavity.klass, "taper=", VALUEFUNC(_wrap_SlitCavity_taper_set), -1);
    rb_define_method(cSlitCavity.klass, "taper", VALUEFUNC(_wrap_SlitCavity_taper_get), -1);
    rb_define_method(cSlitCavity.klass, "size_const=", VALUEFUNC(_wrap_SlitCavity_size_const_set), -1);
    rb_define_method(cSlitCavity.klass, "size_const", VALUEFUNC(_wrap_SlitCavity_size_const_get), -1);
    rb_define_method(cSlitCavity.klass, "make_cavity", VALUEFUNC(_wrap_SlitCavity_make_cavity), -1);
    cSlitCavity.mark = 0;
    cSlitCavity.destroy = (void (*)(void *)) free_SlitCavity;
}

---