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


#ifndef SWIGGUILE
#define SWIGGUILE
#endif

#define SWIG_GUILE_INIT_STATIC extern
extern "C" {

SWIG_GUILE_INIT_STATIC void
SWIG_init (void);

}


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

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

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

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

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

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

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

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

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

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

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

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

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

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif

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

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

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

/* This should only be incremented when either the layout of swig_type_info changes,
   or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"

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

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

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

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

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

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2
#define SWIG_POINTER_NO_NULL       0x4

/* Flags for new pointer objects */
#define SWIG_POINTER_OWN           0x1


/*
   Flags/methods for returning states.

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

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

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

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

   Now you can be more explicit:

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

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

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

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

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

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

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

       int food(double)
       int fooi(int);

   and you call

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

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

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

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

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


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

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

/* Structure to store information on one type */
typedef struct swig_type_info {
  const char             *name;			/* mangled name of this type */
  const char             *str;			/* human readable name of this type */
  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
  void                   *clientdata;		/* language specific type data */
  int                    owndata;		/* flag if the structure owns the clientdata */
} swig_type_info;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#ifdef __cplusplus
}
#endif

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



/* -----------------------------------------------------------------------------
 * guile_scm_run.swg
 * ----------------------------------------------------------------------------- */

#include <libguile.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>

#ifdef __cplusplus
extern "C" {
#endif


/* In the code below, use guile 2.0 compatible functions where possible.
   Functions that don't exist in older versions will be mapped to
   a deprecated equivalent for those versions only */
#if defined (SCM_MAJOR_VERSION) && (SCM_MAJOR_VERSION < 2)

static SCM
scm_module_variable (SCM module, SCM sym)
{
  return scm_sym2var (sym, scm_module_lookup_closure (module), SCM_BOOL_F);
}

#define scm_to_utf8_string scm_to_locale_string
#define scm_from_utf8_string scm_from_locale_string
#endif

#if SCM_MAJOR_VERSION >= 2
/* scm_c_define_gsubr takes a different parameter type depending on the guile version */

typedef scm_t_subr swig_guile_proc;
#else
#if SCM_MAJOR_VERSION >= 2
  typedef scm_t_subr swig_guile_proc;
#else
  typedef SCM (*swig_guile_proc)();
#endif
#endif
typedef SCM (*guile_destructor)(SCM);

typedef struct swig_guile_clientdata {
  guile_destructor destroy;
  SCM goops_class;
} swig_guile_clientdata;

#define SWIG_scm2str(s) \
  SWIG_Guile_scm2newstr(s, NULL)
#define SWIG_str02scm(str) \
  str ? scm_from_utf8_string(str) : SCM_BOOL_F 
# define SWIG_malloc(size) \
  scm_malloc(size)
# define SWIG_free(mem) \
  free(mem)
#define SWIG_ConvertPtr(s, result, type, flags) \
  SWIG_Guile_ConvertPtr(s, result, type, flags)
#define SWIG_MustGetPtr(s, type, argnum, flags) \
  SWIG_Guile_MustGetPtr(s, type, argnum, flags, FUNC_NAME)
#define SWIG_NewPointerObj(ptr, type, owner) \
  SWIG_Guile_NewPointerObj((void*)ptr, type, owner)
#define SWIG_PointerAddress(object) \
  SWIG_Guile_PointerAddress(object)
#define SWIG_PointerType(object) \
  SWIG_Guile_PointerType(object)
#define SWIG_IsPointerOfType(object, type) \
  SWIG_Guile_IsPointerOfType(object, type)
#define SWIG_IsPointer(object) \
  SWIG_Guile_IsPointer(object)
#define SWIG_contract_assert(expr, msg)				\
  if (!(expr))							\
    scm_error(scm_from_locale_symbol("swig-contract-assertion-failed"),	\
	      (char *) FUNC_NAME, (char *) msg,			\
	      SCM_EOL, SCM_BOOL_F); else

/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty) \
  SWIG_Guile_ConvertMember(obj, ptr, sz, ty, FUNC_NAME)
#define SWIG_NewMemberObj(ptr, sz, type) \
  SWIG_Guile_NewMemberObj(ptr, sz, type, FUNC_NAME)
  
/* Runtime API */
static swig_module_info *SWIG_Guile_GetModule(void *SWIGUNUSEDPARM(clientdata));
#define SWIG_GetModule(clientdata) SWIG_Guile_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer) SWIG_Guile_SetModule(pointer)
  
SWIGINTERN char *
SWIG_Guile_scm2newstr(SCM str, size_t *len) {
#define FUNC_NAME "SWIG_Guile_scm2newstr"
  char *ret;

  SCM_ASSERT (scm_is_string(str), str, 1, FUNC_NAME);

  ret = scm_to_utf8_string(str);
  if (!ret) return NULL;

  if (len) *len = strlen(ret) - 1;
  return ret;
#undef FUNC_NAME
}

static int swig_initialized = 0;
static scm_t_bits swig_tag = 0;
static scm_t_bits swig_collectable_tag = 0;
static scm_t_bits swig_finalized_tag = 0;
static scm_t_bits swig_destroyed_tag = 0;
static scm_t_bits swig_member_function_tag = 0;
static SCM swig_make_func = SCM_EOL;
static SCM swig_keyword = SCM_EOL;
static SCM swig_symbol = SCM_EOL;

#define SWIG_Guile_GetSmob(x) \
  ( !scm_is_null(x) && SCM_INSTANCEP(x) && scm_is_true(scm_slot_exists_p(x, swig_symbol)) \
      ? scm_slot_ref(x, swig_symbol) : (x) )

SWIGINTERN SCM
SWIG_Guile_NewPointerObj(void *ptr, swig_type_info *type, int owner)
{
  if (ptr == NULL)
    return SCM_EOL;
  else {
    SCM smob;
    swig_guile_clientdata *cdata = (swig_guile_clientdata *) type->clientdata;
    if (owner)
      SCM_NEWSMOB2(smob, swig_collectable_tag, ptr, (void *) type);
    else
      SCM_NEWSMOB2(smob, swig_tag, ptr, (void *) type);

    if (!cdata || SCM_NULLP(cdata->goops_class) || swig_make_func == SCM_EOL ) {
      return smob;
    } else {
      /* the scm_make() C function only handles the creation of gf,
	 methods and classes (no instances) the (make ...) function is
	 later redefined in goops.scm.  So we need to call that
	 Scheme function. */
      return scm_apply(swig_make_func,
		       scm_list_3(cdata->goops_class,
				  swig_keyword,
				  smob),
		       SCM_EOL);
    }
  }
}

SWIGINTERN unsigned long
SWIG_Guile_PointerAddress(SCM object)
{
  SCM smob = SWIG_Guile_GetSmob(object);
  if (SCM_NULLP(smob)) return 0;
  else if (SCM_SMOB_PREDICATE(swig_tag, smob)
	   || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)
	   || SCM_SMOB_PREDICATE(swig_destroyed_tag, smob)) {
    return (unsigned long) (void *) SCM_CELL_WORD_1(smob);
  }
  else scm_wrong_type_arg("SWIG-Guile-PointerAddress", 1, object);
}

SWIGINTERN swig_type_info *
SWIG_Guile_PointerType(SCM object)
{
  SCM smob = SWIG_Guile_GetSmob(object);
  if (SCM_NULLP(smob)) return NULL;
  else if (SCM_SMOB_PREDICATE(swig_tag, smob)
	   || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)
	   || SCM_SMOB_PREDICATE(swig_destroyed_tag, smob)) {
    return (swig_type_info *) SCM_CELL_WORD_2(smob);
  }
  else scm_wrong_type_arg("SWIG-Guile-PointerType", 1, object);
}

SWIGINTERN int
SWIG_Guile_IsValidSmob(SCM smob)
{
  /* We do not accept smobs representing destroyed pointers, but we have to
     allow finalized smobs because Guile >= 2.0.12 sets all smob instances
     to the 'finalized' type before calling their 'free' function. This change
     was introduced to Guile in commit 8dff3af087c6eaa83ae0d72aa8b22aef5c65d65d */
  return SCM_SMOB_PREDICATE(swig_tag, smob)
    || SCM_SMOB_PREDICATE(swig_collectable_tag, smob)
    || SCM_SMOB_PREDICATE(swig_finalized_tag, smob);
}

SWIGINTERN int
SWIG_Guile_ConvertPtr(SCM s, void **result, swig_type_info *type, int flags)
{
  swig_cast_info *cast;
  swig_type_info *from;
  SCM smob = SWIG_Guile_GetSmob(s);

  if (SCM_NULLP(smob)) {
    *result = NULL;
    return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
#if SCM_MAJOR_VERSION >= 2
  } else if (SCM_POINTER_P(s)) {
    *result = SCM_POINTER_VALUE(s);
    return SWIG_OK;
#endif /* if SCM_MAJOR_VERSION >= 2 */
  } else if (SWIG_Guile_IsValidSmob(smob)) {
    from = (swig_type_info *) SCM_CELL_WORD_2(smob);
    if (!from) return SWIG_ERROR;
    if (type) {
      cast = SWIG_TypeCheckStruct(from, type);
      if (cast) {
        int newmemory = 0;
        *result = SWIG_TypeCast(cast, (void *) SCM_CELL_WORD_1(smob), &newmemory);
        assert(!newmemory); /* newmemory handling not yet implemented */
        return SWIG_OK;
      } else {
        return SWIG_ERROR;
      }
    } else {
      *result = (void *) SCM_CELL_WORD_1(smob);
      return SWIG_OK;
    }
  }
  return SWIG_ERROR;
}

SWIGINTERNINLINE void *
SWIG_Guile_MustGetPtr (SCM s, swig_type_info *type,
		       int argnum, int flags, const char *func_name)
{
  void *result;
  int res = SWIG_Guile_ConvertPtr(s, &result, type, flags);
  if (!SWIG_IsOK(res)) {
    /* type mismatch */
    scm_wrong_type_arg((char *) func_name, argnum, s);
  }
  return result;
}

SWIGINTERNINLINE int
SWIG_Guile_IsPointerOfType (SCM s, swig_type_info *type)
{
  void *result;
  if (SWIG_Guile_ConvertPtr(s, &result, type, 0)) {
    /* type mismatch */
    return 0;
  }
  else return 1;
}

SWIGINTERNINLINE int
SWIG_Guile_IsPointer (SCM s)
{
  /* module might not be initialized yet, so initialize it */
  SWIG_GetModule(0);
  return SWIG_Guile_IsPointerOfType (s, NULL);
}

/* Mark a pointer object non-collectable */
SWIGINTERN void
SWIG_Guile_MarkPointerNoncollectable(SCM s)
{
  SCM smob = SWIG_Guile_GetSmob(s);
  if (!SCM_NULLP(smob)) {
    if (SWIG_Guile_IsValidSmob(smob)) {
      SCM_SET_CELL_TYPE(smob, swig_tag);
    }
    else scm_wrong_type_arg(NULL, 0, s);
  }
}

/* Mark a pointer object destroyed */
SWIGINTERN void
SWIG_Guile_MarkPointerDestroyed(SCM s)
{
  SCM smob = SWIG_Guile_GetSmob(s);
  if (!SCM_NULLP(smob)) {
    if (SWIG_Guile_IsValidSmob(smob)) {
      SCM_SET_CELL_TYPE(smob, swig_destroyed_tag);
    }
    else scm_wrong_type_arg(NULL, 0, s);
  }
}

/* Member functions */

SWIGINTERN SCM
SWIG_Guile_NewMemberObj(void *ptr, size_t sz, swig_type_info *type,
			const char *func_name)
{
  SCM smob;
  void *copy = malloc(sz);
  memcpy(copy, ptr, sz);
  SCM_NEWSMOB2(smob, swig_member_function_tag, copy, (void *) type);
  return smob;
}

SWIGINTERN int
SWIG_Guile_ConvertMember(SCM smob, void *ptr, size_t sz, swig_type_info *type,
			 const char *func_name)
{
  swig_cast_info *cast;
  swig_type_info *from;

  if (SCM_SMOB_PREDICATE(swig_member_function_tag, smob)) {
    from = (swig_type_info *) SCM_CELL_WORD_2(smob);
    if (!from) return SWIG_ERROR;
    if (type) {
      cast = SWIG_TypeCheckStruct(from, type);
      if (!cast) return SWIG_ERROR;
    }
    memcpy(ptr, (void *) SCM_CELL_WORD_1(smob), sz);
    return SWIG_OK;
  }
  return SWIG_ERROR;
}
     

/* Init */

SWIGINTERN int
print_swig_aux (SCM swig_smob, SCM port, scm_print_state *pstate, 
                const char *attribute)
{
  swig_type_info *type;
  
  type = (swig_type_info *) SCM_CELL_WORD_2(swig_smob);
  if (type) {
    scm_puts((char *) "#<", port);
    scm_puts((char *) attribute, port);
    scm_puts((char *) "swig-pointer ", port);
    scm_puts((char *) SWIG_TypePrettyName(type), port);
    scm_puts((char *) " ", port);
    scm_intprint((long) SCM_CELL_WORD_1(swig_smob), 16, port);
    scm_puts((char *) ">", port);
    /* non-zero means success */
    return 1;
  } else {
    return 0;
  }
}

  
SWIGINTERN int
print_swig (SCM swig_smob, SCM port, scm_print_state *pstate)
{
  return print_swig_aux(swig_smob, port, pstate, "");
}

SWIGINTERN int
print_collectable_swig (SCM swig_smob, SCM port, scm_print_state *pstate)
{
  return print_swig_aux(swig_smob, port, pstate, "collectable-");
}

SWIGINTERN int
print_destroyed_swig (SCM swig_smob, SCM port, scm_print_state *pstate)
{
  return print_swig_aux(swig_smob, port, pstate, "destroyed-");
}

SWIGINTERN int
print_member_function_swig (SCM swig_smob, SCM port, scm_print_state *pstate)
{
  swig_type_info *type;
  type = (swig_type_info *) SCM_CELL_WORD_2(swig_smob);
  if (type) {
    scm_puts((char *) "#<", port);
    scm_puts((char *) "swig-member-function-pointer ", port);
    scm_puts((char *) SWIG_TypePrettyName(type), port);
    scm_puts((char *) " >", port);
    /* non-zero means success */
    return 1;
  } else {
    return 0;
  }
}

SWIGINTERN SCM
equalp_swig (SCM A, SCM B)
{
  if (SCM_CELL_WORD_0(A) == SCM_CELL_WORD_0(B) && SCM_CELL_WORD_1(A) == SCM_CELL_WORD_1(B) 
      && SCM_CELL_WORD_2(A) == SCM_CELL_WORD_2(B))
    return SCM_BOOL_T;
  else return SCM_BOOL_F;
}

SWIGINTERN size_t
free_swig(SCM A)
{
  swig_type_info *type = (swig_type_info *) SCM_CELL_WORD_2(A);
  if (type) {
    if (type->clientdata && ((swig_guile_clientdata *)type->clientdata)->destroy)
      ((swig_guile_clientdata *)type->clientdata)->destroy(A);
  } 
  return 0;
}

SWIGINTERN size_t
free_swig_member_function(SCM A)
{
  free((swig_type_info *) SCM_CELL_WORD_1(A));
  return 0;
}

SWIGINTERN int
ensure_smob_tag(SCM swig_module,
		scm_t_bits *tag_variable,
		const char *smob_name,
		const char *scheme_variable_name)
{
  SCM variable = scm_module_variable(swig_module,
                             scm_from_locale_symbol(scheme_variable_name));
  if (scm_is_false(variable)) {
    *tag_variable = scm_make_smob_type((char*)scheme_variable_name, 0);
    scm_c_module_define(swig_module, scheme_variable_name, 
                        scm_from_ulong(*tag_variable));
    return 1;
  }
  else {
    *tag_variable = scm_to_ulong(SCM_VARIABLE_REF(variable));
    return 0;
  }
}

SWIGINTERN SCM
SWIG_Guile_Init ()
{
  static SCM swig_module;
  
  if (swig_initialized) return swig_module;
  swig_initialized = 1;

  swig_module = scm_c_resolve_module("Swig swigrun");
  if (ensure_smob_tag(swig_module, &swig_tag,
		      "swig-pointer", "swig-pointer-tag")) {
    scm_set_smob_print(swig_tag, print_swig);
    scm_set_smob_equalp(swig_tag, equalp_swig);
  }
  if (ensure_smob_tag(swig_module, &swig_collectable_tag,
		      "collectable-swig-pointer", "collectable-swig-pointer-tag")) {
    scm_set_smob_print(swig_collectable_tag, print_collectable_swig);
    scm_set_smob_equalp(swig_collectable_tag, equalp_swig);
    scm_set_smob_free(swig_collectable_tag, free_swig);
    /* For Guile >= 2.0.12. See libguile/smob.c:clear_smobnum */
    swig_finalized_tag = swig_collectable_tag & ~0xff00;
  }
  if (ensure_smob_tag(swig_module, &swig_destroyed_tag,
		      "destroyed-swig-pointer", "destroyed-swig-pointer-tag")) {
    scm_set_smob_print(swig_destroyed_tag, print_destroyed_swig);
    scm_set_smob_equalp(swig_destroyed_tag, equalp_swig);
  }
  if (ensure_smob_tag(swig_module, &swig_member_function_tag,
		      "swig-member-function-pointer", "swig-member-function-pointer-tag")) {
    scm_set_smob_print(swig_member_function_tag, print_member_function_swig);
    scm_set_smob_free(swig_member_function_tag, free_swig_member_function);
  }
  swig_make_func = scm_permanent_object(
  scm_variable_ref(scm_c_module_lookup(scm_c_resolve_module("oop goops"), "make")));
  swig_keyword = scm_permanent_object(scm_from_locale_keyword((char*) "init-smob"));
  swig_symbol = scm_permanent_object(scm_from_locale_symbol("swig-smob"));
#ifdef SWIG_INIT_RUNTIME_MODULE
  SWIG_INIT_RUNTIME_MODULE
#endif

  return swig_module;
}

SWIGINTERN swig_module_info *
SWIG_Guile_GetModule(void *SWIGUNUSEDPARM(clientdata))
{
  SCM module = SWIG_Guile_Init();
  SCM variable = scm_module_variable(module, scm_from_locale_symbol("swig-type-list-address" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME));
  if (scm_is_false(variable)) {
    return NULL;
  } else {
    return (swig_module_info *) scm_to_ulong(SCM_VARIABLE_REF(variable));
  }
}

SWIGINTERN void
SWIG_Guile_SetModule(swig_module_info *swig_module)
{
  SCM module = SWIG_Guile_Init();
  scm_module_define(module,
                    scm_from_locale_symbol("swig-type-list-address" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME),
                    scm_from_ulong((unsigned long) swig_module));
}

SWIGINTERN int
SWIG_Guile_GetArgs (SCM *dest, SCM rest,
		    int reqargs, int optargs,
		    const char *procname)
{
  int i;
  int num_args_passed = 0;
  for (i = 0; i<reqargs; i++) {
    if (!SCM_CONSP(rest))
      scm_wrong_num_args(scm_from_utf8_string(procname ? (char *) procname : "unknown procedure"));
    *dest++ = SCM_CAR(rest);
    rest = SCM_CDR(rest);
    num_args_passed++;
  }
  for (i = 0; i<optargs && SCM_CONSP(rest); i++) {
    *dest++ = SCM_CAR(rest);
    rest = SCM_CDR(rest);
    num_args_passed++;
  }
  for (; i<optargs; i++)
    *dest++ = SCM_UNDEFINED;
  if (!SCM_NULLP(rest))
      scm_wrong_num_args(scm_from_utf8_string(procname ? (char *) procname : "unknown procedure"));
  return num_args_passed;
}

#ifdef __cplusplus
}
#endif



#define GUILE_MAYBE_VALUES \
      if (gswig_list_p) gswig_result = scm_values(gswig_result);

#define GUILE_MAYBE_VECTOR \
      if (gswig_list_p) gswig_result = scm_vector(gswig_result);

#define SWIG_APPEND_VALUE(object)						\
    if (gswig_result == SCM_UNSPECIFIED)						\
        gswig_result = object;							\
    else {									\
      if (!gswig_list_p) {							\
	      gswig_list_p = 1;							\
	      gswig_result = scm_list_n(gswig_result, object, SCM_UNDEFINED);	\
      }									\
      else									\
            gswig_result = scm_append(scm_list_n(gswig_result, scm_list_n(object, SCM_UNDEFINED), SCM_UNDEFINED));		\
    }


static swig_guile_clientdata _swig_guile_clientdatasigned_direction = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_vec = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_ivec = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_volume = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_grid_volume = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_symmetry = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_volume_list = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_initialize = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_susceptibility = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_lorentzian_susceptibility = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_noisy_lorentzian_susceptibility = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_gyrotropic_susceptibility = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_multilevel_susceptibility = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_h5file = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_material_function = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_simple_material_function = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_structure_chunk = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_boundary_region = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_structure = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_src_time = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_gaussian_src_time = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_continuous_src_time = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_custom_src_time = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_monitor_point = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_dft_chunk = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_dft_flux = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_dft_energy = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_dft_force = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatasourcedata = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_dft_near2far = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_dft_ldos = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_dft_fields = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatapolarization_state = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatatiming_scope = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_chunkloop_field_components = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_diffractedplanewave = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_gaussianbeam = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_fields = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_flux_vol = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatasplit_plane = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatameep_binary_partition = { NULL, SCM_EOL };
static swig_guile_clientdata _swig_guile_clientdatakpoint_list = { NULL, SCM_EOL };

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

#define SWIGTYPE_p_FILE swig_types[0]
#define SWIGTYPE_p_a_2__p_double swig_types[1]
#define SWIGTYPE_p_a_5__bool swig_types[2]
#define SWIGTYPE_p_a_5__meep__boundary_condition swig_types[3]
#define SWIGTYPE_p_a_5__p_double swig_types[4]
#define SWIGTYPE_p_a_9__std__complexT_double_t swig_types[5]
#define SWIGTYPE_p_access_mode swig_types[6]
#define SWIGTYPE_p_bool swig_types[7]
#define SWIGTYPE_p_boundary_region_kind swig_types[8]
#define SWIGTYPE_p_ctlio__cnumber_list swig_types[9]
#define SWIGTYPE_p_ctlio__geometric_object_list swig_types[10]
#define SWIGTYPE_p_ctlio__material_type swig_types[11]
#define SWIGTYPE_p_ctlio__material_type_list swig_types[12]
#define SWIGTYPE_p_ctlio__pml_list swig_types[13]
#define SWIGTYPE_p_ctlio__symmetry_list swig_types[14]
#define SWIGTYPE_p_double swig_types[15]
#define SWIGTYPE_p_f_double_int_p_void__meep__vec swig_types[16]
#define SWIGTYPE_p_f_double_p_void__double swig_types[17]
#define SWIGTYPE_p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void swig_types[18]
#define SWIGTYPE_p_f_p_q_const__char__void swig_types[19]
#define SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double swig_types[20]
#define SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t swig_types[21]
#define SWIGTYPE_p_f_r_q_const__meep__vec__double swig_types[22]
#define SWIGTYPE_p_float swig_types[23]
#define SWIGTYPE_p_int swig_types[24]
#define SWIGTYPE_p_kpoint_list swig_types[25]
#define SWIGTYPE_p_long_double swig_types[26]
#define SWIGTYPE_p_meep__binary_partition swig_types[27]
#define SWIGTYPE_p_meep__boundary_region swig_types[28]
#define SWIGTYPE_p_meep__chunkloop_field_components swig_types[29]
#define SWIGTYPE_p_meep__component swig_types[30]
#define SWIGTYPE_p_meep__continuous_src_time swig_types[31]
#define SWIGTYPE_p_meep__custom_src_time swig_types[32]
#define SWIGTYPE_p_meep__dft_chunk swig_types[33]
#define SWIGTYPE_p_meep__dft_energy swig_types[34]
#define SWIGTYPE_p_meep__dft_fields swig_types[35]
#define SWIGTYPE_p_meep__dft_flux swig_types[36]
#define SWIGTYPE_p_meep__dft_force swig_types[37]
#define SWIGTYPE_p_meep__dft_ldos swig_types[38]
#define SWIGTYPE_p_meep__dft_near2far swig_types[39]
#define SWIGTYPE_p_meep__diffractedplanewave swig_types[40]
#define SWIGTYPE_p_meep__direction swig_types[41]
#define SWIGTYPE_p_meep__fields swig_types[42]
#define SWIGTYPE_p_meep__fields_chunk swig_types[43]
#define SWIGTYPE_p_meep__flux_vol swig_types[44]
#define SWIGTYPE_p_meep__gaussian_src_time swig_types[45]
#define SWIGTYPE_p_meep__gaussianbeam swig_types[46]
#define SWIGTYPE_p_meep__grid_volume swig_types[47]
#define SWIGTYPE_p_meep__gyrotropic_susceptibility swig_types[48]
#define SWIGTYPE_p_meep__gyrotropy_model swig_types[49]
#define SWIGTYPE_p_meep__h5file swig_types[50]
#define SWIGTYPE_p_meep__h5file__extending_s swig_types[51]
#define SWIGTYPE_p_meep__initialize swig_types[52]
#define SWIGTYPE_p_meep__ivec swig_types[53]
#define SWIGTYPE_p_meep__lorentzian_susceptibility swig_types[54]
#define SWIGTYPE_p_meep__material_function swig_types[55]
#define SWIGTYPE_p_meep__monitor_point swig_types[56]
#define SWIGTYPE_p_meep__multilevel_susceptibility swig_types[57]
#define SWIGTYPE_p_meep__noisy_lorentzian_susceptibility swig_types[58]
#define SWIGTYPE_p_meep__polarization_state_s swig_types[59]
#define SWIGTYPE_p_meep__signed_direction swig_types[60]
#define SWIGTYPE_p_meep__simple_material_function swig_types[61]
#define SWIGTYPE_p_meep__sourcedata swig_types[62]
#define SWIGTYPE_p_meep__split_plane swig_types[63]
#define SWIGTYPE_p_meep__src_time swig_types[64]
#define SWIGTYPE_p_meep__structure swig_types[65]
#define SWIGTYPE_p_meep__structure_chunk swig_types[66]
#define SWIGTYPE_p_meep__susceptibility swig_types[67]
#define SWIGTYPE_p_meep__symmetry swig_types[68]
#define SWIGTYPE_p_meep__timing_scope swig_types[69]
#define SWIGTYPE_p_meep__vec swig_types[70]
#define SWIGTYPE_p_meep__volume swig_types[71]
#define SWIGTYPE_p_meep__volume_list swig_types[72]
#define SWIGTYPE_p_p_double swig_types[73]
#define SWIGTYPE_p_p_meep__continuous_src_time swig_types[74]
#define SWIGTYPE_p_p_meep__custom_src_time swig_types[75]
#define SWIGTYPE_p_p_meep__dft_chunk swig_types[76]
#define SWIGTYPE_p_p_meep__fields_chunk swig_types[77]
#define SWIGTYPE_p_p_meep__gaussian_src_time swig_types[78]
#define SWIGTYPE_p_p_meep__gyrotropic_susceptibility swig_types[79]
#define SWIGTYPE_p_p_meep__lorentzian_susceptibility swig_types[80]
#define SWIGTYPE_p_p_meep__multilevel_susceptibility swig_types[81]
#define SWIGTYPE_p_p_meep__noisy_lorentzian_susceptibility swig_types[82]
#define SWIGTYPE_p_p_meep__src_time swig_types[83]
#define SWIGTYPE_p_p_meep__structure_chunk swig_types[84]
#define SWIGTYPE_p_p_meep__susceptibility swig_types[85]
#define SWIGTYPE_p_p_p_char swig_types[86]
#define SWIGTYPE_p_p_std__complexT_double_t swig_types[87]
#define SWIGTYPE_p_p_void swig_types[88]
#define SWIGTYPE_p_ptrdiff_t swig_types[89]
#define SWIGTYPE_p_size_t swig_types[90]
#define SWIGTYPE_p_std__complexT_double_t swig_types[91]
#define SWIGTYPE_p_std__complexT_float_t swig_types[92]
#define SWIGTYPE_p_std__complexT_long_double_t swig_types[93]
#define SWIGTYPE_p_std__pairT_int_int_t swig_types[94]
#define SWIGTYPE_p_std__unique_ptrT_meep__binary_partition_t swig_types[95]
#define SWIGTYPE_p_std__unordered_mapT_meep__time_sink_double_std__hashT_int_t_t swig_types[96]
#define SWIGTYPE_p_std__unordered_mapT_meep__time_sink_std__vectorT_double_t_std__hashT_int_t_t swig_types[97]
#define SWIGTYPE_p_std__vectorT_double_t swig_types[98]
#define SWIGTYPE_p_std__vectorT_int_t swig_types[99]
#define SWIGTYPE_p_std__vectorT_meep__component_t swig_types[100]
#define SWIGTYPE_p_std__vectorT_meep__grid_volume_t swig_types[101]
#define SWIGTYPE_p_std__vectorT_meep__sourcedata_t swig_types[102]
#define SWIGTYPE_p_std__vectorT_ptrdiff_t_t swig_types[103]
#define SWIGTYPE_p_std__vectorT_size_t_t swig_types[104]
#define SWIGTYPE_p_std__vectorT_std__complexT_double_t_t swig_types[105]
#define SWIGTYPE_p_unsigned_long swig_types[106]
#define SWIGTYPE_p_vector3 swig_types[107]
#define SWIGTYPE_p_void swig_types[108]
static swig_type_info *swig_types[110];
static swig_module_info swig_module = {swig_types, 109, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

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


#include "meep-ctl.hpp"

#if SCM_MAJOR_VERSION >= 2
#  define SCM_VECTORP(o) scm_vector_p(o)
#  define SCM_VECTOR_LENGTH(o) scm_c_vector_length(o)
#endif

static inline int SwigComplex_Check(SCM o) {
  return SCM_REALP(o) || SCM_COMPLEXP(o);
}

static inline int SwigVector3_Check(SCM o) {
  return SCM_VECTORP(o) && SCM_VECTOR_LENGTH(o) == 3;
}

/* Unfortunately, this is not re-entrant.  Damn dynamic scoping.
   Hopefully, it should be good enough for our purposes. */
static SCM my_complex_func_scm;
static inline std::complex<double> my_complex_func(meep::vec const &v) {
  SCM ret = gh_call1(my_complex_func_scm,
		     ctl_convert_vector3_to_scm(vec_to_vector3(v)));
  cnumber cret = ctl_convert_cnumber_to_c(ret);
  return std::complex<double>(cret.re, cret.im);
}

static inline std::complex<double> my_complex_func2(double t, void *f) {
  SCM ret = gh_call1((SCM) f, ctl_convert_number_to_scm(t));
  cnumber cret = ctl_convert_cnumber_to_c(ret);
  return std::complex<double>(cret.re, cret.im);
}

typedef struct { SCM func; int nf; } my_field_func_data;
static inline std::complex<double> my_field_func(const std::complex<meep::realnum> *fields,
                                                 const meep::vec &loc,
                                                 void *data_) {
  my_field_func_data *data = (my_field_func_data *) data_;
  int num_items = data->nf;
  cnumber *items = new cnumber[num_items];
  for (int i = 0; i < num_items; ++i)
    items[i] = make_cnumber(real(fields[i]), imag(fields[i]));
  SCM ret = scm_apply_0(data->func,
		     scm_cons(ctl_convert_vector3_to_scm(vec_to_vector3(loc)),
			      make_cnumber_list(num_items, items)));
  delete[] items;
  cnumber cret = ctl_convert_cnumber_to_c(ret);
  return std::complex<double>(cret.re, cret.im);
}

/* Unfortunately, this is not re-entrant.  Damn dynamic scoping.
   Hopefully, it should be good enough for our purposes. */
static SCM my_complex_func3_scm;
static inline std::complex<double> my_complex_func3(std::complex<double> x) {
  cnumber cx;
  cx.re = real(x); cx.im = imag(x);
  SCM ret = gh_call1(my_complex_func3_scm, ctl_convert_cnumber_to_scm(cx));
  cnumber cret = ctl_convert_cnumber_to_c(ret);
  return std::complex<double>(cret.re, cret.im);
}

static meep::vec my_kpoint_func(double freq, int mode, void *user_data) {
  SCM scm_res = gh_call2((SCM)user_data, ctl_convert_number_to_scm(freq),
                         ctl_convert_number_to_scm(mode));
  vector3 v3 = ctl_convert_vector3_to_c(scm_res);
  meep::vec result(v3.x, v3.y, v3.z);
  return result;
}


static int gswig_const_meep_component_Ex = (int)(meep::Ex);
static int gswig_const_meep_component_Ey = (int)(meep::Ey);
static int gswig_const_meep_component_Er = (int)(meep::Er);
static int gswig_const_meep_component_Ep = (int)(meep::Ep);
static int gswig_const_meep_component_Ez = (int)(meep::Ez);
static int gswig_const_meep_component_Hx = (int)(meep::Hx);
static int gswig_const_meep_component_Hy = (int)(meep::Hy);
static int gswig_const_meep_component_Hr = (int)(meep::Hr);
static int gswig_const_meep_component_Hp = (int)(meep::Hp);
static int gswig_const_meep_component_Hz = (int)(meep::Hz);
static int gswig_const_meep_component_Dx = (int)(meep::Dx);
static int gswig_const_meep_component_Dy = (int)(meep::Dy);
static int gswig_const_meep_component_Dr = (int)(meep::Dr);
static int gswig_const_meep_component_Dp = (int)(meep::Dp);
static int gswig_const_meep_component_Dz = (int)(meep::Dz);
static int gswig_const_meep_component_Bx = (int)(meep::Bx);
static int gswig_const_meep_component_By = (int)(meep::By);
static int gswig_const_meep_component_Br = (int)(meep::Br);
static int gswig_const_meep_component_Bp = (int)(meep::Bp);
static int gswig_const_meep_component_Bz = (int)(meep::Bz);
static int gswig_const_meep_component_Dielectric = (int)(meep::Dielectric);
static int gswig_const_meep_component_Permeability = (int)(meep::Permeability);
static int gswig_const_meep_component_NO_COMPONENT = (int)(meep::NO_COMPONENT);
static int gswig_const_meep_derived_component_Sx = (int)(meep::Sx);
static int gswig_const_meep_derived_component_Sy = (int)(meep::Sy);
static int gswig_const_meep_derived_component_Sr = (int)(meep::Sr);
static int gswig_const_meep_derived_component_Sp = (int)(meep::Sp);
static int gswig_const_meep_derived_component_Sz = (int)(meep::Sz);
static int gswig_const_meep_derived_component_EnergyDensity = (int)(meep::EnergyDensity);
static int gswig_const_meep_derived_component_D_EnergyDensity = (int)(meep::D_EnergyDensity);
static int gswig_const_meep_derived_component_H_EnergyDensity = (int)(meep::H_EnergyDensity);
static int gswig_const_meep_ndim_D1 = (int)(meep::D1);
static int gswig_const_meep_ndim_D2 = (int)(meep::D2);
static int gswig_const_meep_ndim_D3 = (int)(meep::D3);
static int gswig_const_meep_ndim_Dcyl = (int)(meep::Dcyl);
static int gswig_const_meep_field_type_E_stuff = (int)(meep::E_stuff);
static int gswig_const_meep_field_type_H_stuff = (int)(meep::H_stuff);
static int gswig_const_meep_field_type_D_stuff = (int)(meep::D_stuff);
static int gswig_const_meep_field_type_B_stuff = (int)(meep::B_stuff);
static int gswig_const_meep_field_type_PE_stuff = (int)(meep::PE_stuff);
static int gswig_const_meep_field_type_PH_stuff = (int)(meep::PH_stuff);
static int gswig_const_meep_field_type_WE_stuff = (int)(meep::WE_stuff);
static int gswig_const_meep_field_type_WH_stuff = (int)(meep::WH_stuff);
static int gswig_const_meep_boundary_side_High = (int)(meep::High);
static int gswig_const_meep_boundary_side_Low = (int)(meep::Low);
static int gswig_const_meep_direction_X = (int)(meep::X);
static int gswig_const_meep_direction_Y = (int)(meep::Y);
static int gswig_const_meep_direction_Z = (int)(meep::Z);
static int gswig_const_meep_direction_R = (int)(meep::R);
static int gswig_const_meep_direction_P = (int)(meep::P);
static int gswig_const_meep_direction_NO_DIRECTION = (int)(meep::NO_DIRECTION);
static double gswig_const_MEEP_MIN_OUTPUT_TIME = (double)(4.0);
static int gswig_const_GYROTROPIC_LORENTZIAN = (int)(meep::GYROTROPIC_LORENTZIAN);
static int gswig_const_GYROTROPIC_DRUDE = (int)(meep::GYROTROPIC_DRUDE);
static int gswig_const_GYROTROPIC_SATURATED = (int)(meep::GYROTROPIC_SATURATED);
static int gswig_const_meep_h5file_READONLY = (int)(meep::h5file::READONLY);
static int gswig_const_meep_h5file_READWRITE = (int)(meep::h5file::READWRITE);
static int gswig_const_meep_h5file_WRITE = (int)(meep::h5file::WRITE);
static double gswig_const_DEFAULT_SUBPIXEL_TOL = (double)(1e-4);
static int gswig_const_DEFAULT_SUBPIXEL_MAXEVAL = (int)(100000);
static int gswig_const_meep_boundary_region_NOTHING_SPECIAL = (int)(meep::boundary_region::NOTHING_SPECIAL);
static int gswig_const_meep_boundary_region_PML = (int)(meep::boundary_region::PML);
static int gswig_const_meep_in_or_out_Incoming = (int)(meep::Incoming);
static int gswig_const_meep_in_or_out_Outgoing = (int)(meep::Outgoing);
static int gswig_const_meep_connect_phase_CONNECT_PHASE = (int)(meep::CONNECT_PHASE);
static int gswig_const_meep_connect_phase_CONNECT_NEGATE = (int)(meep::CONNECT_NEGATE);
static int gswig_const_meep_connect_phase_CONNECT_COPY = (int)(meep::CONNECT_COPY);
static int gswig_const_meep_boundary_condition_Periodic = (int)(meep::Periodic);
static int gswig_const_meep_boundary_condition_Metallic = (int)(meep::Metallic);
static int gswig_const_meep_boundary_condition_Magnetic = (int)(meep::Magnetic);
static int gswig_const_meep_boundary_condition_None = (int)(meep::None);
static int gswig_const_meep_time_sink_Connecting = (int)(meep::Connecting);
static int gswig_const_meep_time_sink_Stepping = (int)(meep::Stepping);
static int gswig_const_meep_time_sink_Boundaries = (int)(meep::Boundaries);
static int gswig_const_meep_time_sink_MpiAllTime = (int)(meep::MpiAllTime);
static int gswig_const_meep_time_sink_MpiOneTime = (int)(meep::MpiOneTime);
static int gswig_const_meep_time_sink_FieldOutput = (int)(meep::FieldOutput);
static int gswig_const_meep_time_sink_FourierTransforming = (int)(meep::FourierTransforming);
static int gswig_const_meep_time_sink_MPBTime = (int)(meep::MPBTime);
static int gswig_const_meep_time_sink_GetFarfieldsTime = (int)(meep::GetFarfieldsTime);
static int gswig_const_meep_time_sink_Other = (int)(meep::Other);
static int gswig_const_meep_time_sink_FieldUpdateB = (int)(meep::FieldUpdateB);
static int gswig_const_meep_time_sink_FieldUpdateH = (int)(meep::FieldUpdateH);
static int gswig_const_meep_time_sink_FieldUpdateD = (int)(meep::FieldUpdateD);
static int gswig_const_meep_time_sink_FieldUpdateE = (int)(meep::FieldUpdateE);
static int gswig_const_meep_time_sink_BoundarySteppingB = (int)(meep::BoundarySteppingB);
static int gswig_const_meep_time_sink_BoundarySteppingWH = (int)(meep::BoundarySteppingWH);
static int gswig_const_meep_time_sink_BoundarySteppingPH = (int)(meep::BoundarySteppingPH);
static int gswig_const_meep_time_sink_BoundarySteppingH = (int)(meep::BoundarySteppingH);
static int gswig_const_meep_time_sink_BoundarySteppingD = (int)(meep::BoundarySteppingD);
static int gswig_const_meep_time_sink_BoundarySteppingWE = (int)(meep::BoundarySteppingWE);
static int gswig_const_meep_time_sink_BoundarySteppingPE = (int)(meep::BoundarySteppingPE);
static int gswig_const_meep_time_sink_BoundarySteppingE = (int)(meep::BoundarySteppingE);

#include "ctl-io.h"


#include "meep-ctl-swig.hpp"

static int gswig_const_MEEP_CTL_SWIG_HPP = (int)(1);
static SCM
_wrap_NUM_FIELD_COMPONENTS(SCM s_0)
{
#define FUNC_NAME "NUM-FIELD-COMPONENTS"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(meep::NUM_FIELD_COMPONENTS);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_NUM_FIELD_TYPES(SCM s_0)
{
#define FUNC_NAME "NUM-FIELD-TYPES"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(meep::NUM_FIELD_TYPES);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Ex(SCM s_0)
{
#define FUNC_NAME "meep-component-Ex"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Ex);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Ey(SCM s_0)
{
#define FUNC_NAME "meep-component-Ey"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Ey);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Er(SCM s_0)
{
#define FUNC_NAME "meep-component-Er"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Er);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Ep(SCM s_0)
{
#define FUNC_NAME "meep-component-Ep"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Ep);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Ez(SCM s_0)
{
#define FUNC_NAME "meep-component-Ez"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Ez);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Hx(SCM s_0)
{
#define FUNC_NAME "meep-component-Hx"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Hx);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Hy(SCM s_0)
{
#define FUNC_NAME "meep-component-Hy"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Hy);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Hr(SCM s_0)
{
#define FUNC_NAME "meep-component-Hr"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Hr);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Hp(SCM s_0)
{
#define FUNC_NAME "meep-component-Hp"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Hp);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Hz(SCM s_0)
{
#define FUNC_NAME "meep-component-Hz"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Hz);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Dx(SCM s_0)
{
#define FUNC_NAME "meep-component-Dx"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Dx);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Dy(SCM s_0)
{
#define FUNC_NAME "meep-component-Dy"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Dy);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Dr(SCM s_0)
{
#define FUNC_NAME "meep-component-Dr"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Dr);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Dp(SCM s_0)
{
#define FUNC_NAME "meep-component-Dp"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Dp);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Dz(SCM s_0)
{
#define FUNC_NAME "meep-component-Dz"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Dz);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Bx(SCM s_0)
{
#define FUNC_NAME "meep-component-Bx"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Bx);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_By(SCM s_0)
{
#define FUNC_NAME "meep-component-By"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_By);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Br(SCM s_0)
{
#define FUNC_NAME "meep-component-Br"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Br);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Bp(SCM s_0)
{
#define FUNC_NAME "meep-component-Bp"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Bp);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Bz(SCM s_0)
{
#define FUNC_NAME "meep-component-Bz"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Bz);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Dielectric(SCM s_0)
{
#define FUNC_NAME "meep-component-Dielectric"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Dielectric);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_Permeability(SCM s_0)
{
#define FUNC_NAME "meep-component-Permeability"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_Permeability);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_NO_COMPONENT(SCM s_0)
{
#define FUNC_NAME "meep-component-NO-COMPONENT"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_component_NO_COMPONENT);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_Centered(SCM s_0)
{
#define FUNC_NAME "Centered"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long((int)meep::Centered); 
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_derived_component_Sx(SCM s_0)
{
#define FUNC_NAME "meep-derived-component-Sx"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_derived_component_Sx);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_derived_component_Sy(SCM s_0)
{
#define FUNC_NAME "meep-derived-component-Sy"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_derived_component_Sy);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_derived_component_Sr(SCM s_0)
{
#define FUNC_NAME "meep-derived-component-Sr"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_derived_component_Sr);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_derived_component_Sp(SCM s_0)
{
#define FUNC_NAME "meep-derived-component-Sp"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_derived_component_Sp);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_derived_component_Sz(SCM s_0)
{
#define FUNC_NAME "meep-derived-component-Sz"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_derived_component_Sz);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_derived_component_EnergyDensity(SCM s_0)
{
#define FUNC_NAME "meep-derived-component-EnergyDensity"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_derived_component_EnergyDensity);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_derived_component_D_EnergyDensity(SCM s_0)
{
#define FUNC_NAME "meep-derived-component-D-EnergyDensity"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_derived_component_D_EnergyDensity);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_derived_component_H_EnergyDensity(SCM s_0)
{
#define FUNC_NAME "meep-derived-component-H-EnergyDensity"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_derived_component_H_EnergyDensity);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ndim_D1(SCM s_0)
{
#define FUNC_NAME "meep-ndim-D1"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_ndim_D1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ndim_D2(SCM s_0)
{
#define FUNC_NAME "meep-ndim-D2"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_ndim_D2);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ndim_D3(SCM s_0)
{
#define FUNC_NAME "meep-ndim-D3"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_ndim_D3);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ndim_Dcyl(SCM s_0)
{
#define FUNC_NAME "meep-ndim-Dcyl"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_ndim_Dcyl);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_field_type_E_stuff(SCM s_0)
{
#define FUNC_NAME "meep-field-type-E-stuff"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_field_type_E_stuff);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_field_type_H_stuff(SCM s_0)
{
#define FUNC_NAME "meep-field-type-H-stuff"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_field_type_H_stuff);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_field_type_D_stuff(SCM s_0)
{
#define FUNC_NAME "meep-field-type-D-stuff"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_field_type_D_stuff);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_field_type_B_stuff(SCM s_0)
{
#define FUNC_NAME "meep-field-type-B-stuff"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_field_type_B_stuff);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_field_type_PE_stuff(SCM s_0)
{
#define FUNC_NAME "meep-field-type-PE-stuff"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_field_type_PE_stuff);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_field_type_PH_stuff(SCM s_0)
{
#define FUNC_NAME "meep-field-type-PH-stuff"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_field_type_PH_stuff);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_field_type_WE_stuff(SCM s_0)
{
#define FUNC_NAME "meep-field-type-WE-stuff"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_field_type_WE_stuff);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_field_type_WH_stuff(SCM s_0)
{
#define FUNC_NAME "meep-field-type-WH-stuff"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_field_type_WH_stuff);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_boundary_side_High(SCM s_0)
{
#define FUNC_NAME "meep-boundary-side-High"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_boundary_side_High);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_boundary_side_Low(SCM s_0)
{
#define FUNC_NAME "meep-boundary-side-Low"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_boundary_side_Low);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_direction_X(SCM s_0)
{
#define FUNC_NAME "meep-direction-X"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_direction_X);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_direction_Y(SCM s_0)
{
#define FUNC_NAME "meep-direction-Y"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_direction_Y);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_direction_Z(SCM s_0)
{
#define FUNC_NAME "meep-direction-Z"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_direction_Z);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_direction_R(SCM s_0)
{
#define FUNC_NAME "meep-direction-R"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_direction_R);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_direction_P(SCM s_0)
{
#define FUNC_NAME "meep-direction-P"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_direction_P);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_direction_NO_DIRECTION(SCM s_0)
{
#define FUNC_NAME "meep-direction-NO-DIRECTION"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_direction_NO_DIRECTION);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_signed_direction__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-signed-direction"
  meep::direction arg1 ;
  bool arg2 ;
  std::complex< double > arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::signed_direction *result = 0 ;
  
  {
    arg1 = (meep::direction) scm_to_int(argv[0]); 
  }
  {
    arg2 = (bool) scm_is_true(argv[1]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[2]);
    arg3 = std::complex<double>(cnum.re, cnum.im);
  }
  result = (meep::signed_direction *)new meep::signed_direction(arg1,arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__signed_direction, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_signed_direction__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-signed-direction"
  meep::direction arg1 ;
  bool arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::signed_direction *result = 0 ;
  
  {
    arg1 = (meep::direction) scm_to_int(argv[0]); 
  }
  {
    arg2 = (bool) scm_is_true(argv[1]);
  }
  result = (meep::signed_direction *)new meep::signed_direction(arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__signed_direction, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_signed_direction__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-signed-direction"
  meep::direction arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::signed_direction *result = 0 ;
  
  {
    arg1 = (meep::direction) scm_to_int(argv[0]); 
  }
  result = (meep::signed_direction *)new meep::signed_direction(arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__signed_direction, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_signed_direction__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "new-signed-direction"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::signed_direction *result = 0 ;
  
  result = (meep::signed_direction *)new meep::signed_direction();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__signed_direction, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_signed_direction(SCM rest)
{
#define FUNC_NAME "new-signed-direction"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "new-signed-direction");
  if (argc == 0) {
    return _wrap_new_signed_direction__SWIG_3(argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_new_signed_direction__SWIG_2(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = SCM_BOOLP(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_new_signed_direction__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = SCM_BOOLP(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = SwigComplex_Check(argv[2]);
        }
        if (_v) {
          return _wrap_new_signed_direction__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("new-signed-direction", "No matching method for generic function `new_signed_direction'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_signed_direction_d_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "signed-direction-d-set"
  meep::signed_direction *arg1 = (meep::signed_direction *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::signed_direction *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__signed_direction, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  if (arg1) (arg1)->d = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_signed_direction_d_get (SCM s_0)
{
#define FUNC_NAME "signed-direction-d-get"
  meep::signed_direction *arg1 = (meep::signed_direction *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::direction result;
  
  {
    arg1 = (meep::signed_direction *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__signed_direction, 1, 0);
  }
  result = (meep::direction) ((arg1)->d);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_signed_direction_flipped_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "signed-direction-flipped-set"
  meep::signed_direction *arg1 = (meep::signed_direction *) 0 ;
  bool arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::signed_direction *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__signed_direction, 1, 0);
  }
  {
    arg2 = (bool) scm_is_true(s_1);
  }
  if (arg1) (arg1)->flipped = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_signed_direction_flipped_get (SCM s_0)
{
#define FUNC_NAME "signed-direction-flipped-get"
  meep::signed_direction *arg1 = (meep::signed_direction *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::signed_direction *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__signed_direction, 1, 0);
  }
  result = (bool) ((arg1)->flipped);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_signed_direction_phase_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "signed-direction-phase-set"
  meep::signed_direction *arg1 = (meep::signed_direction *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::signed_direction *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__signed_direction, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  if (arg1) (arg1)->phase = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_signed_direction_phase_get (SCM s_0)
{
#define FUNC_NAME "signed-direction-phase-get"
  meep::signed_direction *arg1 = (meep::signed_direction *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::signed_direction *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__signed_direction, 1, 0);
  }
  result =  ((arg1)->phase);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_signed_direction (SCM s_0)
{
#define FUNC_NAME "delete-signed-direction"
  meep::signed_direction *arg1 = (meep::signed_direction *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::signed_direction *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__signed_direction, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_number_of_directions (SCM s_0)
{
#define FUNC_NAME "meep-number-of-directions"
  meep::ndim arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::ndim) scm_to_int(s_0); 
  }
  result = (int)meep::number_of_directions(arg1);
  {
    gswig_result = scm_from_long(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_start_at_direction (SCM s_0)
{
#define FUNC_NAME "meep-start-at-direction"
  meep::ndim arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::direction result;
  
  {
    arg1 = (meep::ndim) scm_to_int(s_0); 
  }
  result = (meep::direction)meep::start_at_direction(arg1);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_stop_at_direction (SCM s_0)
{
#define FUNC_NAME "meep-stop-at-direction"
  meep::ndim arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::direction result;
  
  {
    arg1 = (meep::ndim) scm_to_int(s_0); 
  }
  result = (meep::direction)meep::stop_at_direction(arg1);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_first_field_component (SCM s_0)
{
#define FUNC_NAME "meep-first-field-component"
  meep::field_type arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::component result;
  
  {
    arg1 = (meep::field_type) scm_to_int(s_0); 
  }
  result = (meep::component)meep::first_field_component(arg1);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_flip (SCM s_0)
{
#define FUNC_NAME "meep-flip"
  meep::signed_direction arg1 ;
  meep::signed_direction *argp1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::signed_direction result;
  
  {
    argp1 = (meep::signed_direction *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__signed_direction, 1, 0);
    arg1 = *argp1;
  }
  result = meep::flip(arg1);
  {
    meep::signed_direction * resultptr;
    resultptr = new meep::signed_direction((const meep::signed_direction &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__signed_direction, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_has_direction (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-has-direction"
  meep::ndim arg1 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::ndim) scm_to_int(s_0); 
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = (bool)meep::has_direction(arg1,arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_has_field_direction (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-has-field-direction"
  meep::ndim arg1 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::ndim) scm_to_int(s_0); 
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = (bool)meep::has_field_direction(arg1,arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_coordinate_mismatch__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-coordinate-mismatch"
  meep::ndim arg1 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::ndim) scm_to_int(argv[0]); 
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  result = (bool)meep::coordinate_mismatch(arg1,arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_is_tm (SCM s_0)
{
#define FUNC_NAME "meep-is-tm"
  meep::component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::component) scm_to_int(s_0); 
  }
  result = (bool)meep::is_tm(arg1);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_abort (SCM s_0)
{
#define FUNC_NAME "meep-abort"
  char *arg1 = (char *) 0 ;
  void *arg2 = 0 ;
  int must_free1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (char *)SWIG_scm2str(s_0);
    must_free1 = 1;
  }
  meep::abort((char const *)arg1,arg2);
  gswig_result = SCM_UNSPECIFIED;
  if (must_free1 && arg1) SWIG_free(arg1);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_is_electric (SCM s_0)
{
#define FUNC_NAME "meep-is-electric"
  meep::component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::component) scm_to_int(s_0); 
  }
  result = (bool)meep::is_electric(arg1);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_is_magnetic (SCM s_0)
{
#define FUNC_NAME "meep-is-magnetic"
  meep::component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::component) scm_to_int(s_0); 
  }
  result = (bool)meep::is_magnetic(arg1);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_is_D (SCM s_0)
{
#define FUNC_NAME "meep-is-D"
  meep::component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::component) scm_to_int(s_0); 
  }
  result = (bool)meep::is_D(arg1);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_is_B (SCM s_0)
{
#define FUNC_NAME "meep-is-B"
  meep::component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::component) scm_to_int(s_0); 
  }
  result = (bool)meep::is_B(arg1);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_is_E_or_D (SCM s_0)
{
#define FUNC_NAME "meep-is-E-or-D"
  meep::component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::component) scm_to_int(s_0); 
  }
  result = (bool)meep::is_E_or_D(arg1);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_is_H_or_B (SCM s_0)
{
#define FUNC_NAME "meep-is-H-or-B"
  meep::component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::component) scm_to_int(s_0); 
  }
  result = (bool)meep::is_H_or_B(arg1);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_is_derived (SCM s_0)
{
#define FUNC_NAME "meep-is-derived"
  int arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (int) scm_to_int(s_0);
  }
  result = (bool)meep::is_derived(arg1);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_is_poynting (SCM s_0)
{
#define FUNC_NAME "meep-is-poynting"
  meep::derived_component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::derived_component) scm_to_int(s_0); 
  }
  result = (bool)meep::is_poynting(arg1);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_is_energydensity (SCM s_0)
{
#define FUNC_NAME "meep-is-energydensity"
  meep::derived_component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::derived_component) scm_to_int(s_0); 
  }
  result = (bool)meep::is_energydensity(arg1);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_type (SCM s_0)
{
#define FUNC_NAME "meep-type"
  meep::component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::field_type result;
  
  {
    arg1 = (meep::component) scm_to_int(s_0); 
  }
  result = (meep::field_type)meep::type(arg1);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_name__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-component-name"
  meep::component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::component) scm_to_int(argv[0]); 
  }
  result = (char *)meep::component_name(arg1);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_name__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-component-name"
  meep::derived_component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::derived_component) scm_to_int(argv[0]); 
  }
  result = (char *)meep::component_name(arg1);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_name__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-component-name"
  int arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  result = (char *)meep::component_name(arg1);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_name(SCM rest)
{
#define FUNC_NAME "meep-component-name"
  SCM argv[1];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 1, "meep-component-name");
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_component_name__SWIG_0(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_component_name__SWIG_1(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_component_name__SWIG_2(argc,argv);
    }
  }
  
  scm_misc_error("meep-component-name", "No matching method for generic function `meep_component_name'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_direction_name (SCM s_0)
{
#define FUNC_NAME "meep-direction-name"
  meep::direction arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::direction) scm_to_int(s_0); 
  }
  result = (char *)meep::direction_name(arg1);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dimension_name (SCM s_0)
{
#define FUNC_NAME "meep-dimension-name"
  meep::ndim arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::ndim) scm_to_int(s_0); 
  }
  result = (char *)meep::dimension_name(arg1);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_index (SCM s_0)
{
#define FUNC_NAME "meep-component-index"
  meep::component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::component) scm_to_int(s_0); 
  }
  result = (int)meep::component_index(arg1);
  {
    gswig_result = scm_from_long(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_direction__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-component-direction"
  int arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::direction result;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  result = (meep::direction)meep::component_direction(arg1);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_direction_component__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-direction-component"
  int arg1 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  result = (int)meep::direction_component(arg1,arg2);
  {
    gswig_result = scm_from_long(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_direction__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-component-direction"
  meep::component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::direction result;
  
  {
    arg1 = (meep::component) scm_to_int(argv[0]); 
  }
  result = (meep::direction)meep::component_direction(arg1);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_direction__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-component-direction"
  meep::derived_component arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::direction result;
  
  {
    arg1 = (meep::derived_component) scm_to_int(argv[0]); 
  }
  result = (meep::direction)meep::component_direction(arg1);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_component_direction(SCM rest)
{
#define FUNC_NAME "meep-component-direction"
  SCM argv[1];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 1, "meep-component-direction");
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_component_direction__SWIG_0(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_component_direction__SWIG_1(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_component_direction__SWIG_2(argc,argv);
    }
  }
  
  scm_misc_error("meep-component-direction", "No matching method for generic function `meep_component_direction'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_direction_component__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-direction-component"
  meep::component arg1 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::component result;
  
  {
    arg1 = (meep::component) scm_to_int(argv[0]); 
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  result = (meep::component)meep::direction_component(arg1,arg2);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_direction_component__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-direction-component"
  meep::derived_component arg1 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::derived_component result;
  
  {
    arg1 = (meep::derived_component) scm_to_int(argv[0]); 
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  result = (meep::derived_component)meep::direction_component(arg1,arg2);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_direction_component(SCM rest)
{
#define FUNC_NAME "meep-direction-component"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-direction-component");
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_direction_component__SWIG_0(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_direction_component__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_direction_component__SWIG_2(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-direction-component", "No matching method for generic function `meep_direction_component'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_field_type_component (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-field-type-component"
  meep::field_type arg1 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::component result;
  
  {
    arg1 = (meep::field_type) scm_to_int(s_0); 
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = (meep::component)meep::field_type_component(arg1,arg2);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_coordinate_mismatch__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-coordinate-mismatch"
  meep::ndim arg1 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::ndim) scm_to_int(argv[0]); 
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  result = (bool)meep::coordinate_mismatch(arg1,arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_coordinate_mismatch__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-coordinate-mismatch"
  meep::ndim arg1 ;
  meep::derived_component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::ndim) scm_to_int(argv[0]); 
  }
  {
    arg2 = (meep::derived_component) scm_to_int(argv[1]); 
  }
  result = (bool)meep::coordinate_mismatch(arg1,arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_coordinate_mismatch(SCM rest)
{
#define FUNC_NAME "meep-coordinate-mismatch"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-coordinate-mismatch");
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_coordinate_mismatch__SWIG_0(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_coordinate_mismatch__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_coordinate_mismatch__SWIG_2(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-coordinate-mismatch", "No matching method for generic function `meep_coordinate_mismatch'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_cycle_direction (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-cycle-direction"
  meep::ndim arg1 ;
  meep::direction arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::direction result;
  
  {
    arg1 = (meep::ndim) scm_to_int(s_0); 
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (int) scm_to_int(s_2);
  }
  result = (meep::direction)meep::cycle_direction(arg1,arg2,arg3);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_cycle_component (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-cycle-component"
  meep::ndim arg1 ;
  meep::component arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::component result;
  
  {
    arg1 = (meep::ndim) scm_to_int(s_0); 
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (int) scm_to_int(s_2);
  }
  result = (meep::component)meep::cycle_component(arg1,arg2,arg3);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_veccyl (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-veccyl"
  double arg1 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  result = meep::veccyl(arg1,arg2);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_zero_vec (SCM s_0)
{
#define FUNC_NAME "meep-zero-vec"
  meep::ndim arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::ndim) scm_to_int(s_0); 
  }
  result = meep::zero_vec(arg1);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_vec__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-vec"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec *result = 0 ;
  
  result = (meep::vec *)new meep::vec();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__vec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_vec__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-vec"
  meep::ndim arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec *result = 0 ;
  
  {
    arg1 = (meep::ndim) scm_to_int(argv[0]); 
  }
  result = (meep::vec *)new meep::vec(arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__vec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_vec__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-vec"
  meep::ndim arg1 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec *result = 0 ;
  
  {
    arg1 = (meep::ndim) scm_to_int(argv[0]); 
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  result = (meep::vec *)new meep::vec(arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__vec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_vec__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-vec"
  double arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec *result = 0 ;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  result = (meep::vec *)new meep::vec(arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__vec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_vec__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-vec"
  double arg1 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec *result = 0 ;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  result = (meep::vec *)new meep::vec(arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__vec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_vec__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-vec"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec *result = 0 ;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  result = (meep::vec *)new meep::vec(arg1,arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__vec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_vec(SCM rest)
{
#define FUNC_NAME "new-meep-vec"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "new-meep-vec");
  if (argc == 0) {
    return _wrap_new_meep_vec__SWIG_0(argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_new_meep_vec__SWIG_1(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_meep_vec__SWIG_3(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_new_meep_vec__SWIG_2(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_new_meep_vec__SWIG_4(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_new_meep_vec__SWIG_5(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("new-meep-vec", "No matching method for generic function `new_meep_vec'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_vec (SCM s_0)
{
#define FUNC_NAME "delete-meep-vec"
  meep::vec *arg1 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::vec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__vec, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vec_round_float (SCM s_0)
{
#define FUNC_NAME "meep-vec-round-float"
  meep::vec *arg1 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::vec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__vec, 1, 0);
  }
  result = ((meep::vec const *)arg1)->round_float();
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vec_dim_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-vec-dim-set"
  meep::vec *arg1 = (meep::vec *) 0 ;
  meep::ndim arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::vec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__vec, 1, 0);
  }
  {
    arg2 = (meep::ndim) scm_to_int(s_1); 
  }
  if (arg1) (arg1)->dim = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vec_dim_get (SCM s_0)
{
#define FUNC_NAME "meep-vec-dim-get"
  meep::vec *arg1 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ndim result;
  
  {
    arg1 = (meep::vec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__vec, 1, 0);
  }
  result = (meep::ndim) ((arg1)->dim);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vec_r (SCM s_0)
{
#define FUNC_NAME "meep-vec-r"
  meep::vec *arg1 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::vec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__vec, 1, 0);
  }
  result = (double)((meep::vec const *)arg1)->r();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vec_x (SCM s_0)
{
#define FUNC_NAME "meep-vec-x"
  meep::vec *arg1 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::vec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__vec, 1, 0);
  }
  result = (double)((meep::vec const *)arg1)->x();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vec_y (SCM s_0)
{
#define FUNC_NAME "meep-vec-y"
  meep::vec *arg1 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::vec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__vec, 1, 0);
  }
  result = (double)((meep::vec const *)arg1)->y();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vec_z (SCM s_0)
{
#define FUNC_NAME "meep-vec-z"
  meep::vec *arg1 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::vec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__vec, 1, 0);
  }
  result = (double)((meep::vec const *)arg1)->z();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vec_in_direction (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-vec-in-direction"
  meep::vec *arg1 = (meep::vec *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::vec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__vec, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = (double)((meep::vec const *)arg1)->in_direction(arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vec_set_direction (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-vec-set-direction"
  meep::vec *arg1 = (meep::vec *) 0 ;
  meep::direction arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::vec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__vec, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  (arg1)->set_direction(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vec_str__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-vec-str"
  meep::vec *arg1 = (meep::vec *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::vec *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__vec, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (size_t) scm_to_ulong(argv[2]);
  }
  result = (char *)(arg1)->str(arg2,arg3);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vec_str__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-vec-str"
  meep::vec *arg1 = (meep::vec *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::vec *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__vec, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  result = (char *)(arg1)->str(arg2);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vec_str__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-vec-str"
  meep::vec *arg1 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::vec *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__vec, 1, 0);
  }
  result = (char *)(arg1)->str();
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vec_str(SCM rest)
{
#define FUNC_NAME "meep-vec-str"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-vec-str");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__vec, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_vec_str__SWIG_2(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__vec, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_vec_str__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__vec, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_vec_str__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-vec-str", "No matching method for generic function `meep_vec_str'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_vec_project_to_boundary (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-vec-project-to-boundary"
  meep::vec *arg1 = (meep::vec *) 0 ;
  meep::direction arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::vec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__vec, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  result = (double)(arg1)->project_to_boundary(arg2,arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_one_vec (SCM s_0)
{
#define FUNC_NAME "meep-one-vec"
  meep::ndim arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::ndim) scm_to_int(s_0); 
  }
  result = meep::one_vec(arg1);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_abs (SCM s_0)
{
#define FUNC_NAME "meep-abs"
  meep::vec *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  
  meep::vec vec__arg1 = vector3_to_vec(ctl_convert_vector3_to_c(s_0));
  arg1 = &vec__arg1;
  
  result = (double)meep::abs((meep::vec const &)*arg1);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_unit_vec (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-unit-vec"
  meep::ndim arg1 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::ndim) scm_to_int(s_0); 
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = meep::unit_vec(arg1,arg2);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_clean_vec__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-clean-vec"
  meep::vec *arg1 = 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  
  meep::vec vec__arg1 = vector3_to_vec(ctl_convert_vector3_to_c(argv[0]));
  arg1 = &vec__arg1;
  
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  result = meep::clean_vec((meep::vec const &)*arg1,arg2);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_clean_vec__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-clean-vec"
  meep::vec *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  
  meep::vec vec__arg1 = vector3_to_vec(ctl_convert_vector3_to_c(argv[0]));
  arg1 = &vec__arg1;
  
  result = meep::clean_vec((meep::vec const &)*arg1);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_clean_vec(SCM rest)
{
#define FUNC_NAME "meep-clean-vec"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-clean-vec");
  if (argc == 1) {
    int _v;
    {
      _v = SwigVector3_Check(argv[0]);
    }
    if (_v) {
      return _wrap_meep_clean_vec__SWIG_1(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = SwigVector3_Check(argv[0]);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_clean_vec__SWIG_0(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-clean-vec", "No matching method for generic function `meep_clean_vec'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_iveccyl (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-iveccyl"
  int arg1 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (int) scm_to_int(s_0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  result = meep::iveccyl(arg1,arg2);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_zero_ivec (SCM s_0)
{
#define FUNC_NAME "meep-zero-ivec"
  meep::ndim arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::ndim) scm_to_int(s_0); 
  }
  result = meep::zero_ivec(arg1);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_one_ivec (SCM s_0)
{
#define FUNC_NAME "meep-one-ivec"
  meep::ndim arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::ndim) scm_to_int(s_0); 
  }
  result = meep::one_ivec(arg1);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_ivec__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-ivec"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec *result = 0 ;
  
  result = (meep::ivec *)new meep::ivec();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__ivec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_ivec__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-ivec"
  meep::ndim arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec *result = 0 ;
  
  {
    arg1 = (meep::ndim) scm_to_int(argv[0]); 
  }
  result = (meep::ivec *)new meep::ivec(arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__ivec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_ivec__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-ivec"
  meep::ndim arg1 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec *result = 0 ;
  
  {
    arg1 = (meep::ndim) scm_to_int(argv[0]); 
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  result = (meep::ivec *)new meep::ivec(arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__ivec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_ivec__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-ivec"
  int arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec *result = 0 ;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  result = (meep::ivec *)new meep::ivec(arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__ivec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_ivec__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-ivec"
  int arg1 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec *result = 0 ;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  result = (meep::ivec *)new meep::ivec(arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__ivec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_ivec__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-ivec"
  int arg1 ;
  int arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec *result = 0 ;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  result = (meep::ivec *)new meep::ivec(arg1,arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__ivec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_ivec(SCM rest)
{
#define FUNC_NAME "new-meep-ivec"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "new-meep-ivec");
  if (argc == 0) {
    return _wrap_new_meep_ivec__SWIG_0(argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_new_meep_ivec__SWIG_1(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_new_meep_ivec__SWIG_3(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_new_meep_ivec__SWIG_2(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_new_meep_ivec__SWIG_4(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_new_meep_ivec__SWIG_5(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("new-meep-ivec", "No matching method for generic function `new_meep_ivec'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_ivec (SCM s_0)
{
#define FUNC_NAME "delete-meep-ivec"
  meep::ivec *arg1 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__ivec, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ivec_yucky_val (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-ivec-yucky-val"
  meep::ivec *arg1 = (meep::ivec *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__ivec, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  result = (int)((meep::ivec const *)arg1)->yucky_val(arg2);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ivec_dim_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-ivec-dim-set"
  meep::ivec *arg1 = (meep::ivec *) 0 ;
  meep::ndim arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__ivec, 1, 0);
  }
  {
    arg2 = (meep::ndim) scm_to_int(s_1); 
  }
  if (arg1) (arg1)->dim = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ivec_dim_get (SCM s_0)
{
#define FUNC_NAME "meep-ivec-dim-get"
  meep::ivec *arg1 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ndim result;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__ivec, 1, 0);
  }
  result = (meep::ndim) ((arg1)->dim);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ivec_r (SCM s_0)
{
#define FUNC_NAME "meep-ivec-r"
  meep::ivec *arg1 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__ivec, 1, 0);
  }
  result = (int)((meep::ivec const *)arg1)->r();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ivec_x (SCM s_0)
{
#define FUNC_NAME "meep-ivec-x"
  meep::ivec *arg1 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__ivec, 1, 0);
  }
  result = (int)((meep::ivec const *)arg1)->x();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ivec_y (SCM s_0)
{
#define FUNC_NAME "meep-ivec-y"
  meep::ivec *arg1 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__ivec, 1, 0);
  }
  result = (int)((meep::ivec const *)arg1)->y();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ivec_z (SCM s_0)
{
#define FUNC_NAME "meep-ivec-z"
  meep::ivec *arg1 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__ivec, 1, 0);
  }
  result = (int)((meep::ivec const *)arg1)->z();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ivec_in_direction (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-ivec-in-direction"
  meep::ivec *arg1 = (meep::ivec *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__ivec, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = (int)((meep::ivec const *)arg1)->in_direction(arg2);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ivec_set_direction (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-ivec-set-direction"
  meep::ivec *arg1 = (meep::ivec *) 0 ;
  meep::direction arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__ivec, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (int) scm_to_int(s_2);
  }
  (arg1)->set_direction(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ivec_str__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-ivec-str"
  meep::ivec *arg1 = (meep::ivec *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__ivec, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (size_t) scm_to_ulong(argv[2]);
  }
  result = (char *)(arg1)->str(arg2,arg3);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ivec_str__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-ivec-str"
  meep::ivec *arg1 = (meep::ivec *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__ivec, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  result = (char *)(arg1)->str(arg2);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ivec_str__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-ivec-str"
  meep::ivec *arg1 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__ivec, 1, 0);
  }
  result = (char *)(arg1)->str();
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_ivec_str(SCM rest)
{
#define FUNC_NAME "meep-ivec-str"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-ivec-str");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__ivec, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_ivec_str__SWIG_2(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__ivec, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_ivec_str__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__ivec, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_ivec_str__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-ivec-str", "No matching method for generic function `meep_ivec_str'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_ivec_round_down_to_even (SCM s_0)
{
#define FUNC_NAME "meep-ivec-round-down-to-even"
  meep::ivec *arg1 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__ivec, 1, 0);
  }
  result = ((meep::ivec const *)arg1)->round_down_to_even();
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_unit_ivec (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-unit-ivec"
  meep::ndim arg1 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::ndim) scm_to_int(s_0); 
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = meep::unit_ivec(arg1,arg2);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_max__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-max"
  meep::vec *arg1 = 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  
  meep::vec vec__arg1 = vector3_to_vec(ctl_convert_vector3_to_c(argv[0]));
  arg1 = &vec__arg1;
  
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  result = meep::max((meep::vec const &)*arg1,(meep::vec const &)*arg2);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_min__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-min"
  meep::vec *arg1 = 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  
  meep::vec vec__arg1 = vector3_to_vec(ctl_convert_vector3_to_c(argv[0]));
  arg1 = &vec__arg1;
  
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  result = meep::min((meep::vec const &)*arg1,(meep::vec const &)*arg2);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_max__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-max"
  meep::ivec *arg1 = 0 ;
  meep::ivec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__ivec, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__ivec, 2, 0);
  }
  result = meep::max((meep::ivec const &)*arg1,(meep::ivec const &)*arg2);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_max(SCM rest)
{
#define FUNC_NAME "meep-max"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-max");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_max__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = SwigVector3_Check(argv[0]);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        return _wrap_meep_max__SWIG_0(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-max", "No matching method for generic function `meep_max'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_min__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-min"
  meep::ivec *arg1 = 0 ;
  meep::ivec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__ivec, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__ivec, 2, 0);
  }
  result = meep::min((meep::ivec const &)*arg1,(meep::ivec const &)*arg2);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_min(SCM rest)
{
#define FUNC_NAME "meep-min"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-min");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_min__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = SwigVector3_Check(argv[0]);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        return _wrap_meep_min__SWIG_0(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-min", "No matching method for generic function `meep_min'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_max_to_all__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-max-to-all"
  meep::ivec *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::ivec *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__ivec, 1, 0);
  }
  result = meep::max_to_all((meep::ivec const &)*arg1);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_dim_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-volume-dim-set"
  meep::volume *arg1 = (meep::volume *) 0 ;
  meep::ndim arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (meep::ndim) scm_to_int(s_1); 
  }
  if (arg1) (arg1)->dim = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_dim_get (SCM s_0)
{
#define FUNC_NAME "meep-volume-dim-get"
  meep::volume *arg1 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ndim result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  result = (meep::ndim) ((arg1)->dim);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_volume__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-volume"
  meep::ndim arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume *result = 0 ;
  
  {
    arg1 = (meep::ndim) scm_to_int(argv[0]); 
  }
  result = (meep::volume *)new meep::volume(arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_volume__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-volume"
  meep::vec *arg1 = 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume *result = 0 ;
  
  
  meep::vec vec__arg1 = vector3_to_vec(ctl_convert_vector3_to_c(argv[0]));
  arg1 = &vec__arg1;
  
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  result = (meep::volume *)new meep::volume((meep::vec const &)*arg1,(meep::vec const &)*arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_volume__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-volume"
  meep::vec *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume *result = 0 ;
  
  
  meep::vec vec__arg1 = vector3_to_vec(ctl_convert_vector3_to_c(argv[0]));
  arg1 = &vec__arg1;
  
  result = (meep::volume *)new meep::volume((meep::vec const &)*arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_volume(SCM rest)
{
#define FUNC_NAME "new-meep-volume"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "new-meep-volume");
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_new_meep_volume__SWIG_0(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = SwigVector3_Check(argv[0]);
    }
    if (_v) {
      return _wrap_new_meep_volume__SWIG_2(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = SwigVector3_Check(argv[0]);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        return _wrap_new_meep_volume__SWIG_1(argc,argv);
      }
    }
  }
  
  scm_misc_error("new-meep-volume", "No matching method for generic function `new_meep_volume'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_set_direction_min (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-volume-set-direction-min"
  meep::volume *arg1 = (meep::volume *) 0 ;
  meep::direction arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  (arg1)->set_direction_min(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_set_direction_max (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-volume-set-direction-max"
  meep::volume *arg1 = (meep::volume *) 0 ;
  meep::direction arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  (arg1)->set_direction_max(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_in_direction_min (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-volume-in-direction-min"
  meep::volume *arg1 = (meep::volume *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = (double)((meep::volume const *)arg1)->in_direction_min(arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_in_direction_max (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-volume-in-direction-max"
  meep::volume *arg1 = (meep::volume *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = (double)((meep::volume const *)arg1)->in_direction_max(arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_in_direction (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-volume-in-direction"
  meep::volume *arg1 = (meep::volume *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = (double)((meep::volume const *)arg1)->in_direction(arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_computational_volume (SCM s_0)
{
#define FUNC_NAME "meep-volume-computational-volume"
  meep::volume *arg1 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  result = (double)((meep::volume const *)arg1)->computational_volume();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_integral_volume (SCM s_0)
{
#define FUNC_NAME "meep-volume-integral-volume"
  meep::volume *arg1 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  result = (double)((meep::volume const *)arg1)->integral_volume();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_full_volume (SCM s_0)
{
#define FUNC_NAME "meep-volume-full-volume"
  meep::volume *arg1 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  result = (double)((meep::volume const *)arg1)->full_volume();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_center (SCM s_0)
{
#define FUNC_NAME "meep-volume-center"
  meep::volume *arg1 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  result = ((meep::volume const *)arg1)->center();
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_diameter (SCM s_0)
{
#define FUNC_NAME "meep-volume-diameter"
  meep::volume *arg1 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  result = (double)((meep::volume const *)arg1)->diameter();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_contains__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-volume-contains"
  meep::volume *arg1 = (meep::volume *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__volume, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  result = (bool)((meep::volume const *)arg1)->contains((meep::vec const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_contains__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-volume-contains"
  meep::volume *arg1 = (meep::volume *) 0 ;
  meep::volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  result = (bool)((meep::volume const *)arg1)->contains((meep::volume const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_contains(SCM rest)
{
#define FUNC_NAME "meep-volume-contains"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-volume-contains");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_volume_contains__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        return _wrap_meep_volume_contains__SWIG_0(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-volume-contains", "No matching method for generic function `meep_volume_contains'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_intersect_with (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-volume-intersect-with"
  meep::volume *arg1 = (meep::volume *) 0 ;
  meep::volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::volume > result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  result = ((meep::volume const *)arg1)->intersect_with((meep::volume const &)*arg2);
  {
    meep::volume * resultptr;
    resultptr = new meep::volume((const meep::volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__volume, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_round_float (SCM s_0)
{
#define FUNC_NAME "meep-volume-round-float"
  meep::volume *arg1 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::volume > result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  result = ((meep::volume const *)arg1)->round_float();
  {
    meep::volume * resultptr;
    resultptr = new meep::volume((const meep::volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__volume, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_intersects (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-volume-intersects"
  meep::volume *arg1 = (meep::volume *) 0 ;
  meep::volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  result = (bool)((meep::volume const *)arg1)->intersects((meep::volume const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_get_min_corner (SCM s_0)
{
#define FUNC_NAME "meep-volume-get-min-corner"
  meep::volume *arg1 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  result = ((meep::volume const *)arg1)->get_min_corner();
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_get_max_corner (SCM s_0)
{
#define FUNC_NAME "meep-volume-get-max-corner"
  meep::volume *arg1 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  result = ((meep::volume const *)arg1)->get_max_corner();
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_normal_direction (SCM s_0)
{
#define FUNC_NAME "meep-volume-normal-direction"
  meep::volume *arg1 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::direction result;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  result = (meep::direction)((meep::volume const *)arg1)->normal_direction();
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_str__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-volume-str"
  meep::volume *arg1 = (meep::volume *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (size_t) scm_to_ulong(argv[2]);
  }
  result = (char *)(arg1)->str(arg2,arg3);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_str__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-volume-str"
  meep::volume *arg1 = (meep::volume *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  result = (char *)(arg1)->str(arg2);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_str__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-volume-str"
  meep::volume *arg1 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__volume, 1, 0);
  }
  result = (char *)(arg1)->str();
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_str(SCM rest)
{
#define FUNC_NAME "meep-volume-str"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-volume-str");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_volume_str__SWIG_2(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_volume_str__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_volume_str__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-volume-str", "No matching method for generic function `meep_volume_str'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_volume (SCM s_0)
{
#define FUNC_NAME "delete-meep-volume"
  meep::volume *arg1 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volcyl (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-volcyl"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  result = meep::volcyl(arg1,arg2,arg3);
  {
    meep::grid_volume * resultptr;
    resultptr = new meep::grid_volume((const meep::grid_volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__grid_volume, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volone (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-volone"
  double arg1 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  result = meep::volone(arg1,arg2);
  {
    meep::grid_volume * resultptr;
    resultptr = new meep::grid_volume((const meep::grid_volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__grid_volume, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vol1d (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-vol1d"
  double arg1 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  result = meep::vol1d(arg1,arg2);
  {
    meep::grid_volume * resultptr;
    resultptr = new meep::grid_volume((const meep::grid_volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__grid_volume, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_voltwo (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-voltwo"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  result = meep::voltwo(arg1,arg2,arg3);
  {
    meep::grid_volume * resultptr;
    resultptr = new meep::grid_volume((const meep::grid_volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__grid_volume, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vol2d (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-vol2d"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  result = meep::vol2d(arg1,arg2,arg3);
  {
    meep::grid_volume * resultptr;
    resultptr = new meep::grid_volume((const meep::grid_volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__grid_volume, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_vol3d (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-vol3d"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  {
    arg4 = (double) scm_to_double(s_3);
  }
  result = meep::vol3d(arg1,arg2,arg3,arg4);
  {
    meep::grid_volume * resultptr;
    resultptr = new meep::grid_volume((const meep::grid_volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__grid_volume, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_grid_volume ()
{
#define FUNC_NAME "new-meep-grid-volume"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume *result = 0 ;
  
  result = (meep::grid_volume *)new meep::grid_volume();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__grid_volume, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_subvolume (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-grid-volume-subvolume"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::ivec arg2 ;
  meep::ivec arg3 ;
  meep::component arg4 ;
  meep::ivec *argp2 ;
  meep::ivec *argp3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    argp2 = (meep::ivec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__ivec, 2, 0);
    arg2 = *argp2;
  }
  {
    argp3 = (meep::ivec *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__ivec, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = (meep::component) scm_to_int(s_3); 
  }
  result = (arg1)->subvolume(arg2,arg3,arg4);
  {
    meep::grid_volume * resultptr;
    resultptr = new meep::grid_volume((const meep::grid_volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__grid_volume, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_init_subvolume (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-grid-volume-init-subvolume"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::ivec arg2 ;
  meep::ivec arg3 ;
  meep::component arg4 ;
  meep::ivec *argp2 ;
  meep::ivec *argp3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    argp2 = (meep::ivec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__ivec, 2, 0);
    arg2 = *argp2;
  }
  {
    argp3 = (meep::ivec *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__ivec, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = (meep::component) scm_to_int(s_3); 
  }
  (arg1)->init_subvolume(arg2,arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_dim_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-dim-set"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::ndim arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::ndim) scm_to_int(s_1); 
  }
  if (arg1) (arg1)->dim = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_dim_get (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-dim-get"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ndim result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (meep::ndim) ((arg1)->dim);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_a_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-a-set"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->a = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_a_get (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-a-get"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double) ((arg1)->a);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_inva_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-inva-set"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->inva = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_inva_get (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-inva-get"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double) ((arg1)->inva);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_print (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-print"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  ((meep::grid_volume const *)arg1)->print();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_stride (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-stride"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ptrdiff_t result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = ((meep::grid_volume const *)arg1)->stride(arg2);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_num_direction (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-num-direction"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = (int)((meep::grid_volume const *)arg1)->num_direction(arg2);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_yucky_num (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-yucky-num"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  result = (int)((meep::grid_volume const *)arg1)->yucky_num(arg2);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_yucky_direction (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-yucky-direction"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::direction result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  result = (meep::direction)((meep::grid_volume const *)arg1)->yucky_direction(arg2);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_set_num_direction (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-grid-volume-set-num-direction"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::direction arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (int) scm_to_int(s_2);
  }
  (arg1)->set_num_direction(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_nr (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-nr"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (int)((meep::grid_volume const *)arg1)->nr();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_nx (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-nx"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (int)((meep::grid_volume const *)arg1)->nx();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_ny (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-ny"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (int)((meep::grid_volume const *)arg1)->ny();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_nz (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-nz"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (int)((meep::grid_volume const *)arg1)->nz();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_has_field (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-has-field"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = (bool)((meep::grid_volume const *)arg1)->has_field(arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_has_boundary (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-grid-volume-has-boundary"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::boundary_side arg2 ;
  meep::direction arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::boundary_side) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::direction) scm_to_int(s_2); 
  }
  result = (int)((meep::grid_volume const *)arg1)->has_boundary(arg2,arg3);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_dr (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-dr"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->dr();
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_dx (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-dx"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->dx();
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_dy (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-dy"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->dy();
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_dz (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-dz"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->dz();
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_ntot (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-ntot"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  size_t result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->ntot();
  {
    gswig_result = scm_from_ulong(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_nowned_min (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-nowned-min"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  size_t result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->nowned_min();
  {
    gswig_result = scm_from_ulong(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_nowned (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-nowned"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  size_t result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = ((meep::grid_volume const *)arg1)->nowned(arg2);
  {
    gswig_result = scm_from_ulong(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_index (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-grid-volume-index"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  meep::ivec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ptrdiff_t result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::ivec *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__ivec, 3, 0);
  }
  result = ((meep::grid_volume const *)arg1)->index(arg2,(meep::ivec const &)*arg3);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_round_vec (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-round-vec"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(s_1));
  arg2 = &vec__arg2;
  
  result = ((meep::grid_volume const *)arg1)->round_vec((meep::vec const &)*arg2);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_interpolate__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-interpolate"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  meep::vec *arg3 = 0 ;
  ptrdiff_t *arg4 ;
  double *arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(argv[2]));
  arg3 = &vec__arg3;
  
  {
    arg4 = (ptrdiff_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_ptrdiff_t, 4, 0);
  }
  {
    arg5 = (double *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_double, 5, 0);
  }
  ((meep::grid_volume const *)arg1)->interpolate(arg2,(meep::vec const &)*arg3,arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_interpolate__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-interpolate"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  meep::vec *arg3 = 0 ;
  meep::ivec *arg4 ;
  double *arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(argv[2]));
  arg3 = &vec__arg3;
  
  {
    arg4 = (meep::ivec *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__ivec, 4, 0);
  }
  {
    arg5 = (double *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_double, 5, 0);
  }
  ((meep::grid_volume const *)arg1)->interpolate(arg2,(meep::vec const &)*arg3,arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_interpolate(SCM rest)
{
#define FUNC_NAME "meep-grid-volume-interpolate"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-grid-volume-interpolate");
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SwigVector3_Check(argv[2]);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_ptrdiff_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_grid_volume_interpolate__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SwigVector3_Check(argv[2]);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__ivec, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_grid_volume_interpolate__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-grid-volume-interpolate", "No matching method for generic function `meep_grid_volume_interpolate'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_dV__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-dV"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  ptrdiff_t arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::volume > result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (ptrdiff_t) scm_to_long(argv[2]);
  }
  result = ((meep::grid_volume const *)arg1)->dV(arg2,arg3);
  {
    meep::volume * resultptr;
    resultptr = new meep::volume((const meep::volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__volume, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_dV__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-dV"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::ivec *arg2 = 0 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::volume > result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__ivec, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  result = ((meep::grid_volume const *)arg1)->dV((meep::ivec const &)*arg2,arg3);
  {
    meep::volume * resultptr;
    resultptr = new meep::volume((const meep::volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__volume, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_dV__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-dV"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::ivec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::volume > result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__ivec, 2, 0);
  }
  result = ((meep::grid_volume const *)arg1)->dV((meep::ivec const &)*arg2);
  {
    meep::volume * resultptr;
    resultptr = new meep::volume((const meep::volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__volume, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_dV(SCM rest)
{
#define FUNC_NAME "meep-grid-volume-dV"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-grid-volume-dV");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_grid_volume_dV__SWIG_2(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_grid_volume_dV__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_grid_volume_dV__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-grid-volume-dV", "No matching method for generic function `meep_grid_volume_dV'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_intersect_with__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-intersect-with"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::grid_volume *arg2 = 0 ;
  meep::grid_volume *arg3 = (meep::grid_volume *) 0 ;
  meep::grid_volume *arg4 = (meep::grid_volume *) 0 ;
  int *arg5 = (int *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  {
    arg3 = (meep::grid_volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__grid_volume, 3, 0);
  }
  {
    arg4 = (meep::grid_volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__grid_volume, 4, 0);
  }
  {
    arg5 = (int *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_int, 5, 0);
  }
  result = (bool)((meep::grid_volume const *)arg1)->intersect_with((meep::grid_volume const &)*arg2,arg3,arg4,arg5);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_intersect_with__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-intersect-with"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::grid_volume *arg2 = 0 ;
  meep::grid_volume *arg3 = (meep::grid_volume *) 0 ;
  meep::grid_volume *arg4 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  {
    arg3 = (meep::grid_volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__grid_volume, 3, 0);
  }
  {
    arg4 = (meep::grid_volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__grid_volume, 4, 0);
  }
  result = (bool)((meep::grid_volume const *)arg1)->intersect_with((meep::grid_volume const &)*arg2,arg3,arg4);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_intersect_with__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-intersect-with"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::grid_volume *arg2 = 0 ;
  meep::grid_volume *arg3 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  {
    arg3 = (meep::grid_volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__grid_volume, 3, 0);
  }
  result = (bool)((meep::grid_volume const *)arg1)->intersect_with((meep::grid_volume const &)*arg2,arg3);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_intersect_with__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-intersect-with"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::grid_volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  result = (bool)((meep::grid_volume const *)arg1)->intersect_with((meep::grid_volume const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_intersect_with(SCM rest)
{
#define FUNC_NAME "meep-grid-volume-intersect-with"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-grid-volume-intersect-with");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_grid_volume_intersect_with__SWIG_3(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_grid_volume_intersect_with__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_grid_volume_intersect_with__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_grid_volume_intersect_with__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-grid-volume-intersect-with", "No matching method for generic function `meep_grid_volume_intersect_with'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_rmin (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-rmin"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double)((meep::grid_volume const *)arg1)->rmin();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_rmax (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-rmax"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double)((meep::grid_volume const *)arg1)->rmax();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_xmin (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-xmin"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double)((meep::grid_volume const *)arg1)->xmin();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_xmax (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-xmax"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double)((meep::grid_volume const *)arg1)->xmax();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_ymin (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-ymin"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double)((meep::grid_volume const *)arg1)->ymin();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_ymax (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-ymax"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double)((meep::grid_volume const *)arg1)->ymax();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_zmin (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-zmin"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double)((meep::grid_volume const *)arg1)->zmin();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_zmax (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-zmax"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double)((meep::grid_volume const *)arg1)->zmax();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_center (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-center"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->center();
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_icenter (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-icenter"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->icenter();
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_loc (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-grid-volume-loc"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  ptrdiff_t arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (ptrdiff_t) scm_to_long(s_2);
  }
  result = ((meep::grid_volume const *)arg1)->loc(arg2,arg3);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_loc_at_resolution (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-grid-volume-loc-at-resolution"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  ptrdiff_t arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (ptrdiff_t) scm_to_long(s_1);
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  result = ((meep::grid_volume const *)arg1)->loc_at_resolution(arg2,arg3);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_ntot_at_resolution (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-ntot-at-resolution"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  size_t result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  result = ((meep::grid_volume const *)arg1)->ntot_at_resolution(arg2);
  {
    gswig_result = scm_from_ulong(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_iloc (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-grid-volume-iloc"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  ptrdiff_t arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (ptrdiff_t) scm_to_long(s_2);
  }
  result = ((meep::grid_volume const *)arg1)->iloc(arg2,arg3);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_surface_area (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-surface-area"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  size_t result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->surface_area();
  {
    gswig_result = scm_from_ulong(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_yee_index (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-yee-index"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ptrdiff_t result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = ((meep::grid_volume const *)arg1)->yee_index(arg2);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_yee_shift (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-yee-shift"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = ((meep::grid_volume const *)arg1)->yee_shift(arg2);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_eps_component (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-eps-component"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::component result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (meep::component)((meep::grid_volume const *)arg1)->eps_component();
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_yee2cent_offsets (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-grid-volume-yee2cent-offsets"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  ptrdiff_t *arg3 = 0 ;
  ptrdiff_t *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (ptrdiff_t *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_ptrdiff_t, 3, 0);
  }
  {
    arg4 = (ptrdiff_t *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_ptrdiff_t, 4, 0);
  }
  ((meep::grid_volume const *)arg1)->yee2cent_offsets(arg2,*arg3,*arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_cent2yee_offsets (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-grid-volume-cent2yee-offsets"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  ptrdiff_t *arg3 = 0 ;
  ptrdiff_t *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (ptrdiff_t *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_ptrdiff_t, 3, 0);
  }
  {
    arg4 = (ptrdiff_t *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_ptrdiff_t, 4, 0);
  }
  ((meep::grid_volume const *)arg1)->cent2yee_offsets(arg2,*arg3,*arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_boundary_location (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-grid-volume-boundary-location"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::boundary_side arg2 ;
  meep::direction arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::boundary_side) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::direction) scm_to_int(s_2); 
  }
  result = (double)((meep::grid_volume const *)arg1)->boundary_location(arg2,arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_big_corner (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-big-corner"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->big_corner();
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_little_corner (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-little-corner"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->little_corner();
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_corner (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-corner"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::boundary_side arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::boundary_side) scm_to_int(s_1); 
  }
  result = ((meep::grid_volume const *)arg1)->corner(arg2);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_contains__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-contains"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  result = (bool)((meep::grid_volume const *)arg1)->contains((meep::vec const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_contains__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-contains"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::ivec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__ivec, 2, 0);
  }
  result = (bool)((meep::grid_volume const *)arg1)->contains((meep::ivec const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_contains(SCM rest)
{
#define FUNC_NAME "meep-grid-volume-contains"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-grid-volume-contains");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_grid_volume_contains__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        return _wrap_meep_grid_volume_contains__SWIG_0(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-grid-volume-contains", "No matching method for generic function `meep_grid_volume_contains'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_little_owned_corner0 (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-little-owned-corner0"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = ((meep::grid_volume const *)arg1)->little_owned_corner0(arg2);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_little_owned_corner (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-little-owned-corner"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = ((meep::grid_volume const *)arg1)->little_owned_corner(arg2);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_big_owned_corner (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-big-owned-corner"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = ((meep::grid_volume const *)arg1)->big_owned_corner(arg2);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_owns (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-owns"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::ivec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__ivec, 2, 0);
  }
  result = (bool)((meep::grid_volume const *)arg1)->owns((meep::ivec const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_surroundings (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-surroundings"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::volume > result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->surroundings();
  {
    meep::volume * resultptr;
    resultptr = new meep::volume((const meep::volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__volume, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_interior (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-interior"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::volume > result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->interior();
  {
    meep::volume * resultptr;
    resultptr = new meep::volume((const meep::volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__volume, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_get_boundary_icorners (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4)
{
#define FUNC_NAME "meep-grid-volume-get-boundary-icorners"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  int arg3 ;
  meep::ivec *arg4 = (meep::ivec *) 0 ;
  meep::ivec *arg5 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (int) scm_to_int(s_2);
  }
  {
    arg4 = (meep::ivec *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__ivec, 4, 0);
  }
  {
    arg5 = (meep::ivec *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_meep__ivec, 5, 0);
  }
  result = (bool)((meep::grid_volume const *)arg1)->get_boundary_icorners(arg2,arg3,arg4,arg5);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_split_at_fraction (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-grid-volume-split-at-fraction"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  bool arg2 ;
  int arg3 ;
  int arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (bool) scm_is_true(s_1);
  }
  {
    arg3 = (int) scm_to_int(s_2);
  }
  {
    arg4 = (int) scm_to_int(s_3);
  }
  result = ((meep::grid_volume const *)arg1)->split_at_fraction(arg2,arg3,arg4);
  {
    meep::grid_volume * resultptr;
    resultptr = new meep::grid_volume((const meep::grid_volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__grid_volume, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_get_cost (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-get-cost"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double)((meep::grid_volume const *)arg1)->get_cost();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_halve (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-halve"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = ((meep::grid_volume const *)arg1)->halve(arg2);
  {
    meep::grid_volume * resultptr;
    resultptr = new meep::grid_volume((const meep::grid_volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__grid_volume, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_pad_self (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-pad-self"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  (arg1)->pad_self(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_pad__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-pad"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  result = ((meep::grid_volume const *)arg1)->pad(arg2);
  {
    meep::grid_volume * resultptr;
    resultptr = new meep::grid_volume((const meep::grid_volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__grid_volume, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_pad__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-pad"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->pad();
  {
    meep::grid_volume * resultptr;
    resultptr = new meep::grid_volume((const meep::grid_volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__grid_volume, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_pad(SCM rest)
{
#define FUNC_NAME "meep-grid-volume-pad"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-grid-volume-pad");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_grid_volume_pad__SWIG_1(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_grid_volume_pad__SWIG_0(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-grid-volume-pad", "No matching method for generic function `meep_grid_volume_pad'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_iyee_shift (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-iyee-shift"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = ((meep::grid_volume const *)arg1)->iyee_shift(arg2);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_get_origin (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-get-origin"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = ((meep::grid_volume const *)arg1)->get_origin();
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_set_origin__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-set-origin"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  (arg1)->set_origin((meep::vec const &)*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_set_origin__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-set-origin"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::ivec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__ivec, 2, 0);
  }
  (arg1)->set_origin((meep::ivec const &)*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_shift_origin__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-shift-origin"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  (arg1)->shift_origin((meep::vec const &)*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_shift_origin__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-shift-origin"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::ivec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__ivec, 2, 0);
  }
  (arg1)->shift_origin((meep::ivec const &)*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_shift_origin__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-shift-origin"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::direction arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  (arg1)->shift_origin(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_shift_origin(SCM rest)
{
#define FUNC_NAME "meep-grid-volume-shift-origin"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-grid-volume-shift-origin");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_grid_volume_shift_origin__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        return _wrap_meep_grid_volume_shift_origin__SWIG_0(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_grid_volume_shift_origin__SWIG_2(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-grid-volume-shift-origin", "No matching method for generic function `meep_grid_volume_shift_origin'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_set_origin__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-set-origin"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::direction arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  (arg1)->set_origin(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_set_origin(SCM rest)
{
#define FUNC_NAME "meep-grid-volume-set-origin"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-grid-volume-set-origin");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_grid_volume_set_origin__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        return _wrap_meep_grid_volume_set_origin__SWIG_0(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_grid_volume_set_origin__SWIG_2(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-grid-volume-set-origin", "No matching method for generic function `meep_grid_volume_set_origin'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_center_origin (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-center-origin"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  (arg1)->center_origin();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_origin_in_direction (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-origin-in-direction"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = (double)((meep::grid_volume const *)arg1)->origin_in_direction(arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_iorigin_in_direction (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-grid-volume-iorigin-in-direction"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = (int)((meep::grid_volume const *)arg1)->iorigin_in_direction(arg2);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_origin_r (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-origin-r"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double)((meep::grid_volume const *)arg1)->origin_r();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_origin_x (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-origin-x"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double)((meep::grid_volume const *)arg1)->origin_x();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_origin_y (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-origin-y"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double)((meep::grid_volume const *)arg1)->origin_y();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_origin_z (SCM s_0)
{
#define FUNC_NAME "meep-grid-volume-origin-z"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (double)((meep::grid_volume const *)arg1)->origin_z();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_str__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-str"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (size_t) scm_to_ulong(argv[2]);
  }
  result = (char *)(arg1)->str(arg2,arg3);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_str__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-str"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  result = (char *)(arg1)->str(arg2);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_str__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-grid-volume-str"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  result = (char *)(arg1)->str();
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_str(SCM rest)
{
#define FUNC_NAME "meep-grid-volume-str"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-grid-volume-str");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_grid_volume_str__SWIG_2(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_grid_volume_str__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_grid_volume_str__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-grid-volume-str", "No matching method for generic function `meep_grid_volume_str'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_get_split_costs (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-grid-volume-get-split-costs"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  meep::direction arg2 ;
  int arg3 ;
  bool arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (int) scm_to_int(s_2);
  }
  {
    arg4 = (bool) scm_is_true(s_3);
  }
  result = ((meep::grid_volume const *)arg1)->get_split_costs(arg2,arg3,arg4);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_tile_split (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-grid-volume-tile-split"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  int *arg2 = 0 ;
  meep::direction *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (int *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_int, 2, 0);
  }
  {
    arg3 = (meep::direction *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__direction, 3, 0);
  }
  ((meep::grid_volume const *)arg1)->tile_split(*arg2,*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_grid_volume_find_best_split (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5)
{
#define FUNC_NAME "meep-grid-volume-find-best-split"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  int arg2 ;
  bool arg3 ;
  int *arg4 = 0 ;
  meep::direction *arg5 = 0 ;
  double *arg6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  {
    arg3 = (bool) scm_is_true(s_2);
  }
  {
    arg4 = (int *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_int, 4, 0);
  }
  {
    arg5 = (meep::direction *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_meep__direction, 5, 0);
  }
  {
    arg6 = (double *)SWIG_MustGetPtr(s_5, SWIGTYPE_p_double, 6, 0);
  }
  ((meep::grid_volume const *)arg1)->find_best_split(arg2,arg3,*arg4,*arg5,*arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_grid_volume (SCM s_0)
{
#define FUNC_NAME "delete-meep-grid-volume"
  meep::grid_volume *arg1 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_identity ()
{
#define FUNC_NAME "meep-identity"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::symmetry result;
  
  result = meep::identity();
  {
    meep::symmetry * resultptr;
    resultptr = new meep::symmetry((const meep::symmetry &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__symmetry, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_rotate4 (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-rotate4"
  meep::direction arg1 ;
  meep::grid_volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::symmetry result;
  
  {
    arg1 = (meep::direction) scm_to_int(s_0); 
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  result = meep::rotate4(arg1,(meep::grid_volume const &)*arg2);
  {
    meep::symmetry * resultptr;
    resultptr = new meep::symmetry((const meep::symmetry &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__symmetry, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_rotate2 (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-rotate2"
  meep::direction arg1 ;
  meep::grid_volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::symmetry result;
  
  {
    arg1 = (meep::direction) scm_to_int(s_0); 
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  result = meep::rotate2(arg1,(meep::grid_volume const &)*arg2);
  {
    meep::symmetry * resultptr;
    resultptr = new meep::symmetry((const meep::symmetry &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__symmetry, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_mirror (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-mirror"
  meep::direction arg1 ;
  meep::grid_volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::symmetry result;
  
  {
    arg1 = (meep::direction) scm_to_int(s_0); 
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  result = meep::mirror(arg1,(meep::grid_volume const &)*arg2);
  {
    meep::symmetry * resultptr;
    resultptr = new meep::symmetry((const meep::symmetry &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__symmetry, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_r_to_minus_r_symmetry (SCM s_0)
{
#define FUNC_NAME "meep-r-to-minus-r-symmetry"
  double arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::symmetry result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  result = meep::r_to_minus_r_symmetry(arg1);
  {
    meep::symmetry * resultptr;
    resultptr = new meep::symmetry((const meep::symmetry &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__symmetry, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_symmetry__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-symmetry"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::symmetry *result = 0 ;
  
  result = (meep::symmetry *)new meep::symmetry();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__symmetry, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_symmetry__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-symmetry"
  meep::symmetry *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::symmetry *result = 0 ;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  result = (meep::symmetry *)new meep::symmetry((meep::symmetry const &)*arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__symmetry, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_symmetry(SCM rest)
{
#define FUNC_NAME "new-meep-symmetry"
  SCM argv[1];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 1, "new-meep-symmetry");
  if (argc == 0) {
    return _wrap_new_meep_symmetry__SWIG_0(argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_symmetry__SWIG_1(argc,argv);
    }
  }
  
  scm_misc_error("new-meep-symmetry", "No matching method for generic function `new_meep_symmetry'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_symmetry (SCM s_0)
{
#define FUNC_NAME "delete-meep-symmetry"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_transform__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-symmetry-transform"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::direction arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::signed_direction result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  result = ((meep::symmetry const *)arg1)->transform(arg2,arg3);
  {
    meep::signed_direction * resultptr;
    resultptr = new meep::signed_direction((const meep::signed_direction &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__signed_direction, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_transform__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-symmetry-transform"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::ivec *arg2 = 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__ivec, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  result = ((meep::symmetry const *)arg1)->transform((meep::ivec const &)*arg2,arg3);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_transform__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-symmetry-transform"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::vec *arg2 = 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  result = ((meep::symmetry const *)arg1)->transform((meep::vec const &)*arg2,arg3);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_transform_unshifted (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-symmetry-transform-unshifted"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::ivec *arg2 = 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__ivec, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(s_2);
  }
  result = ((meep::symmetry const *)arg1)->transform_unshifted((meep::ivec const &)*arg2,arg3);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_transform__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-symmetry-transform"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::volume *arg2 = 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::volume > result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  result = ((meep::symmetry const *)arg1)->transform((meep::volume const &)*arg2,arg3);
  {
    meep::volume * resultptr;
    resultptr = new meep::volume((const meep::volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__volume, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_transform__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-symmetry-transform"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::component arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::component result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  result = (meep::component)((meep::symmetry const *)arg1)->transform(arg2,arg3);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_phase_shift__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-symmetry-phase-shift"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::component arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  result = ((meep::symmetry const *)arg1)->phase_shift(arg2,arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_transform__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-symmetry-transform"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::derived_component arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::derived_component result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::derived_component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  result = (meep::derived_component)((meep::symmetry const *)arg1)->transform(arg2,arg3);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_phase_shift__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-symmetry-phase-shift"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::derived_component arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::derived_component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  result = ((meep::symmetry const *)arg1)->phase_shift(arg2,arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_transform__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-symmetry-transform"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  int arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  result = (int)((meep::symmetry const *)arg1)->transform(arg2,arg3);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_transform(SCM rest)
{
#define FUNC_NAME "meep-symmetry-transform"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-symmetry-transform");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_symmetry_transform__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_symmetry_transform__SWIG_3(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_symmetry_transform__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_symmetry_transform__SWIG_4(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_symmetry_transform__SWIG_5(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_symmetry_transform__SWIG_6(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_symmetry_transform__SWIG_2(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-symmetry-transform", "No matching method for generic function `meep_symmetry_transform'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_phase_shift__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-symmetry-phase-shift"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  int arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  result = ((meep::symmetry const *)arg1)->phase_shift(arg2,arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_phase_shift(SCM rest)
{
#define FUNC_NAME "meep-symmetry-phase-shift"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-symmetry-phase-shift");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_symmetry_phase_shift__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_symmetry_phase_shift__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_symmetry_phase_shift__SWIG_2(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-symmetry-phase-shift", "No matching method for generic function `meep_symmetry_phase_shift'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_multiplicity__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-symmetry-multiplicity"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  result = (int)((meep::symmetry const *)arg1)->multiplicity();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_multiplicity__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-symmetry-multiplicity"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::ivec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__ivec, 2, 0);
  }
  result = (int)((meep::symmetry const *)arg1)->multiplicity(*arg2);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_multiplicity(SCM rest)
{
#define FUNC_NAME "meep-symmetry-multiplicity"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-symmetry-multiplicity");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_symmetry_multiplicity__SWIG_0(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_symmetry_multiplicity__SWIG_1(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-symmetry-multiplicity", "No matching method for generic function `meep_symmetry_multiplicity'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_is_primitive (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-symmetry-is-primitive"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::ivec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__ivec, 2, 0);
  }
  result = (bool)((meep::symmetry const *)arg1)->is_primitive((meep::ivec const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_reduce (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-symmetry-reduce"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume_list *result = 0 ;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  result = (meep::volume_list *)((meep::symmetry const *)arg1)->reduce((meep::volume_list const *)arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume_list, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_meep_symmetry_add (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-symmetry-meep-symmetry-add"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::symmetry *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::symmetry result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::symmetry *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__symmetry, 2, 0);
  }
  result = ((meep::symmetry const *)arg1)->operator +((meep::symmetry const &)*arg2);
  {
    meep::symmetry * resultptr;
    resultptr = new meep::symmetry((const meep::symmetry &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__symmetry, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_meep_symmetry_mul (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-symmetry-meep-symmetry-mul"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::symmetry result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  result = ((meep::symmetry const *)arg1)->operator *(arg2);
  {
    meep::symmetry * resultptr;
    resultptr = new meep::symmetry((const meep::symmetry &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__symmetry, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_meep_symmetry_sub__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-symmetry-meep-symmetry-sub"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::symmetry *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::symmetry result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::symmetry *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__symmetry, 2, 0);
  }
  result = ((meep::symmetry const *)arg1)->operator -((meep::symmetry const &)*arg2);
  {
    meep::symmetry * resultptr;
    resultptr = new meep::symmetry((const meep::symmetry &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__symmetry, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_meep_symmetry_sub__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-symmetry-meep-symmetry-sub"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::symmetry result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  result = ((meep::symmetry const *)arg1)->operator -();
  {
    meep::symmetry * resultptr;
    resultptr = new meep::symmetry((const meep::symmetry &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__symmetry, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_meep_symmetry_sub(SCM rest)
{
#define FUNC_NAME "meep-symmetry-meep-symmetry-sub"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-symmetry-meep-symmetry-sub");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_symmetry_meep_symmetry_sub__SWIG_1(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__symmetry, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_symmetry_meep_symmetry_sub__SWIG_0(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-symmetry-meep-symmetry-sub", "No matching method for generic function `meep_symmetry_meep_symmetry_sub'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_meep_symmetry_eq (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-symmetry-meep-symmetry-eq"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::symmetry *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::symmetry *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__symmetry, 2, 0);
  }
  result = (bool)((meep::symmetry const *)arg1)->operator ==((meep::symmetry const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_meep_symmetry_neq (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-symmetry-meep-symmetry-neq"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::symmetry *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::symmetry *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__symmetry, 2, 0);
  }
  result = (bool)((meep::symmetry const *)arg1)->operator !=((meep::symmetry const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_i_symmetry_point_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-symmetry-i-symmetry-point-set"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  meep::ivec *arg2 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__ivec, 2, 0);
  }
  if (arg1) (arg1)->i_symmetry_point = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_symmetry_i_symmetry_point_get (SCM s_0)
{
#define FUNC_NAME "meep-symmetry-i-symmetry-point-get"
  meep::symmetry *arg1 = (meep::symmetry *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec *result = 0 ;
  
  {
    arg1 = (meep::symmetry *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__symmetry, 1, 0);
  }
  result = (meep::ivec *)& ((arg1)->i_symmetry_point);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__ivec, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_volume_list__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-volume-list"
  meep::volume *arg1 = 0 ;
  int arg2 ;
  std::complex< double > arg3 ;
  meep::volume_list *arg4 = (meep::volume_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume_list *result = 0 ;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[2]);
    arg3 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg4 = (meep::volume_list *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume_list, 4, 0);
  }
  result = (meep::volume_list *)new meep::volume_list((meep::volume const &)*arg1,arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume_list, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_volume_list__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-volume-list"
  meep::volume *arg1 = 0 ;
  int arg2 ;
  std::complex< double > arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume_list *result = 0 ;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[2]);
    arg3 = std::complex<double>(cnum.re, cnum.im);
  }
  result = (meep::volume_list *)new meep::volume_list((meep::volume const &)*arg1,arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume_list, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_volume_list__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-volume-list"
  meep::volume *arg1 = 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume_list *result = 0 ;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  result = (meep::volume_list *)new meep::volume_list((meep::volume const &)*arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume_list, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_volume_list (SCM s_0)
{
#define FUNC_NAME "delete-meep-volume-list"
  meep::volume_list *arg1 = (meep::volume_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::volume_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume_list, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_volume_list__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-volume-list"
  meep::volume_list *arg1 = (meep::volume_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume_list *result = 0 ;
  
  {
    arg1 = (meep::volume_list *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__volume_list, 1, 0);
  }
  result = (meep::volume_list *)new meep::volume_list((meep::volume_list const *)arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume_list, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_volume_list(SCM rest)
{
#define FUNC_NAME "new-meep-volume-list"
  SCM argv[4];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 4, "new-meep-volume-list");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__volume_list, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_volume_list__SWIG_3(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_new_meep_volume_list__SWIG_2(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SwigComplex_Check(argv[2]);
        }
        if (_v) {
          return _wrap_new_meep_volume_list__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SwigComplex_Check(argv[2]);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume_list, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_meep_volume_list__SWIG_0(argc,argv);
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-volume-list", "No matching method for generic function `new_meep_volume_list'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_list_v_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-volume-list-v-set"
  meep::volume_list *arg1 = (meep::volume_list *) 0 ;
  meep::volume *arg2 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::volume_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume_list, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  if (arg1) (arg1)->v = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_list_v_get (SCM s_0)
{
#define FUNC_NAME "meep-volume-list-v-get"
  meep::volume_list *arg1 = (meep::volume_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume *result = 0 ;
  
  {
    arg1 = (meep::volume_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume_list, 1, 0);
  }
  result = (meep::volume *)& ((arg1)->v);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_list_c_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-volume-list-c-set"
  meep::volume_list *arg1 = (meep::volume_list *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::volume_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume_list, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  if (arg1) (arg1)->c = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_list_c_get (SCM s_0)
{
#define FUNC_NAME "meep-volume-list-c-get"
  meep::volume_list *arg1 = (meep::volume_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::volume_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume_list, 1, 0);
  }
  result = (int) ((arg1)->c);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_list_weight_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-volume-list-weight-set"
  meep::volume_list *arg1 = (meep::volume_list *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::volume_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume_list, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  if (arg1) (arg1)->weight = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_list_weight_get (SCM s_0)
{
#define FUNC_NAME "meep-volume-list-weight-get"
  meep::volume_list *arg1 = (meep::volume_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::volume_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume_list, 1, 0);
  }
  result =  ((arg1)->weight);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_list_next_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-volume-list-next-set"
  meep::volume_list *arg1 = (meep::volume_list *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::volume_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume_list, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  if (arg1) (arg1)->next = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_volume_list_next_get (SCM s_0)
{
#define FUNC_NAME "meep-volume-list-next-get"
  meep::volume_list *arg1 = (meep::volume_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume_list *result = 0 ;
  
  {
    arg1 = (meep::volume_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume_list, 1, 0);
  }
  result = (meep::volume_list *) ((arg1)->next);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume_list, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_wall_time ()
{
#define FUNC_NAME "meep-wall-time"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  result = (double)meep::wall_time();
  {
    gswig_result = scm_from_double(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_initialize (SCM s_0, SCM s_1)
{
#define FUNC_NAME "new-meep-initialize"
  int *arg1 = 0 ;
  char ***arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::initialize *result = 0 ;
  
  {
    arg1 = (int *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_int, 1, 0);
  }
  {
    arg2 = (char ***)SWIG_MustGetPtr(s_1, SWIGTYPE_p_p_p_char, 2, 0);
  }
  result = (meep::initialize *)new meep::initialize(*arg1,*arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__initialize, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_initialize (SCM s_0)
{
#define FUNC_NAME "delete-meep-initialize"
  meep::initialize *arg1 = (meep::initialize *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::initialize *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__initialize, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_initialize_elapsed_time (SCM s_0)
{
#define FUNC_NAME "meep-initialize-elapsed-time"
  meep::initialize *arg1 = (meep::initialize *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::initialize *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__initialize, 1, 0);
  }
  result = (double)(arg1)->elapsed_time();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_all_wait ()
{
#define FUNC_NAME "meep-all-wait"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  meep::all_wait();
  gswig_result = SCM_UNSPECIFIED;
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_count_processors ()
{
#define FUNC_NAME "meep-count-processors"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  result = (int)meep::count_processors();
  {
    gswig_result = scm_from_long(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_my_rank ()
{
#define FUNC_NAME "meep-my-rank"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  result = (int)meep::my_rank();
  {
    gswig_result = scm_from_long(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_am_really_master ()
{
#define FUNC_NAME "meep-am-really-master"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  result = (bool)meep::am_really_master();
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_am_master ()
{
#define FUNC_NAME "meep-am-master"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  result = (int)meep::am_master();
  {
    gswig_result = scm_from_long(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_with_mpi ()
{
#define FUNC_NAME "meep-with-mpi"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  result = (bool)meep::with_mpi();
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_send__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-send"
  int arg1 ;
  int arg2 ;
  double *arg3 = (double *) 0 ;
  int arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  meep::send(arg1,arg2,arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_send__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-send"
  int arg1 ;
  int arg2 ;
  double *arg3 = (double *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  meep::send(arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_send(SCM rest)
{
#define FUNC_NAME "meep-send"
  SCM argv[4];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 4, "meep-send");
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_send__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_send__SWIG_0(argc,argv);
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-send", "No matching method for generic function `meep_send'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_broadcast__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-broadcast"
  int arg1 ;
  float *arg2 = (float *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (float *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_float, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::broadcast(arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_broadcast__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-broadcast"
  int arg1 ;
  double *arg2 = (double *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (double *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_double, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::broadcast(arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_broadcast__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-broadcast"
  int arg1 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::broadcast(arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_broadcast__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-broadcast"
  int arg1 ;
  int *arg2 = (int *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (int *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_int, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::broadcast(arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_broadcast__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-broadcast"
  int arg1 ;
  size_t *arg2 = (size_t *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (size_t *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_size_t, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::broadcast(arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_broadcast__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-broadcast"
  int arg1 ;
  std::complex< double > *arg2 = (std::complex< double > *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (std::complex< double > *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_std__complexT_double_t, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::broadcast(arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_broadcast__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-broadcast"
  int arg1 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[1]);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  result = meep::broadcast(arg1,arg2);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_broadcast__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-broadcast"
  int arg1 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  result = (double)meep::broadcast(arg1,arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_broadcast__SWIG_8 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-broadcast"
  int arg1 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  result = (int)meep::broadcast(arg1,arg2);
  {
    gswig_result = scm_from_long(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_broadcast__SWIG_9 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-broadcast"
  int arg1 ;
  bool arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (bool) scm_is_true(argv[1]);
  }
  result = (bool)meep::broadcast(arg1,arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_broadcast(SCM rest)
{
#define FUNC_NAME "meep-broadcast"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-broadcast");
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = SCM_BOOLP(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_broadcast__SWIG_9(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_broadcast__SWIG_8(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_broadcast__SWIG_7(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = SwigComplex_Check(argv[1]);
      }
      if (_v) {
        return _wrap_meep_broadcast__SWIG_6(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_size_t, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_broadcast__SWIG_4(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_broadcast__SWIG_5(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_broadcast__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_broadcast__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_broadcast__SWIG_3(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_broadcast__SWIG_2(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-broadcast", "No matching method for generic function `meep_broadcast'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_max_to_master (SCM s_0)
{
#define FUNC_NAME "meep-max-to-master"
  double arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  result = (double)meep::max_to_master(arg1);
  {
    gswig_result = scm_from_double(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_max_to_all__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-max-to-all"
  double arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  result = (double)meep::max_to_all(arg1);
  {
    gswig_result = scm_from_double(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_max_to_all__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-max-to-all"
  int arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  result = (int)meep::max_to_all(arg1);
  {
    gswig_result = scm_from_long(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_max_to_all(SCM rest)
{
#define FUNC_NAME "meep-max-to-all"
  SCM argv[1];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 1, "meep-max-to-all");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_max_to_all__SWIG_0(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_max_to_all__SWIG_2(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_max_to_all__SWIG_1(argc,argv);
    }
  }
  
  scm_misc_error("meep-max-to-all", "No matching method for generic function `meep_max_to_all'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_min_to_all (SCM s_0)
{
#define FUNC_NAME "meep-min-to-all"
  int arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (int) scm_to_int(s_0);
  }
  result = (int)meep::min_to_all(arg1);
  {
    gswig_result = scm_from_long(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_master__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-master"
  float arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  float result;
  
  {
    arg1 = (float) scm_to_double(argv[0]);
  }
  result = (float)meep::sum_to_master(arg1);
  {
    gswig_result = scm_from_double(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_master__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-master"
  double arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  result = (double)meep::sum_to_master(arg1);
  {
    gswig_result = scm_from_double(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_all__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-all"
  double arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  result = (double)meep::sum_to_all(arg1);
  {
    gswig_result = scm_from_double(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_all__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-all"
  float *arg1 = (float *) 0 ;
  float *arg2 = (float *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (float *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_float, 1, 0);
  }
  {
    arg2 = (float *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_float, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::sum_to_all((float const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_all__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-all"
  double *arg1 = (double *) 0 ;
  double *arg2 = (double *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (double *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_double, 1, 0);
  }
  {
    arg2 = (double *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_double, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::sum_to_all((double const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_master__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-master"
  float *arg1 = (float *) 0 ;
  float *arg2 = (float *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (float *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_float, 1, 0);
  }
  {
    arg2 = (float *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_float, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::sum_to_master((float const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_master__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-master"
  double *arg1 = (double *) 0 ;
  double *arg2 = (double *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (double *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_double, 1, 0);
  }
  {
    arg2 = (double *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_double, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::sum_to_master((double const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_all__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-all"
  float *arg1 = (float *) 0 ;
  double *arg2 = (double *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (float *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_float, 1, 0);
  }
  {
    arg2 = (double *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_double, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::sum_to_all((float const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_all__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-all"
  std::complex< float > *arg1 = (std::complex< float > *) 0 ;
  std::complex< double > *arg2 = (std::complex< double > *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (std::complex< float > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_float_t, 1, 0);
  }
  {
    arg2 = (std::complex< double > *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_std__complexT_double_t, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::sum_to_all((std::complex< float > const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_all__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-all"
  std::complex< double > *arg1 = (std::complex< double > *) 0 ;
  std::complex< double > *arg2 = (std::complex< double > *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (std::complex< double > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_double_t, 1, 0);
  }
  {
    arg2 = (std::complex< double > *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_std__complexT_double_t, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::sum_to_all((std::complex< double > const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_all__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-all"
  std::complex< float > *arg1 = (std::complex< float > *) 0 ;
  std::complex< float > *arg2 = (std::complex< float > *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (std::complex< float > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_float_t, 1, 0);
  }
  {
    arg2 = (std::complex< float > *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_std__complexT_float_t, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::sum_to_all((std::complex< float > const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_master__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-master"
  std::complex< float > *arg1 = (std::complex< float > *) 0 ;
  std::complex< float > *arg2 = (std::complex< float > *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (std::complex< float > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_float_t, 1, 0);
  }
  {
    arg2 = (std::complex< float > *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_std__complexT_float_t, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::sum_to_master((std::complex< float > const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_master__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-master"
  std::complex< double > *arg1 = (std::complex< double > *) 0 ;
  std::complex< double > *arg2 = (std::complex< double > *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (std::complex< double > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_double_t, 1, 0);
  }
  {
    arg2 = (std::complex< double > *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_std__complexT_double_t, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::sum_to_master((std::complex< double > const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_all__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-all"
  long double arg1 ;
  long double *argp1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  long double result;
  
  {
    argp1 = (long double *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_long_double, 1, 0);
    arg1 = *argp1;
  }
  result = (long double)meep::sum_to_all(arg1);
  {
    long double * resultptr;
    resultptr = new long double((const long double &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_long_double, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_all__SWIG_8 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-all"
  std::complex< double > arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[0]);
    arg1 = std::complex<double>(cnum.re, cnum.im);
  }
  result = meep::sum_to_all(arg1);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_all__SWIG_9 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-all"
  std::complex< long double > arg1 ;
  std::complex< long double > *argp1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< long double > result;
  
  {
    argp1 = (std::complex< long double > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_long_double_t, 1, 0);
    arg1 = *argp1;
  }
  result = meep::sum_to_all(arg1);
  {
    std::complex< long double > * resultptr;
    resultptr = new std::complex< long double >((const std::complex< long double > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__complexT_long_double_t, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_all__SWIG_10 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-all"
  int arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  result = (int)meep::sum_to_all(arg1);
  {
    gswig_result = scm_from_long(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_partial_sum_to_all__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-partial-sum-to-all"
  int arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  result = (int)meep::partial_sum_to_all(arg1);
  {
    gswig_result = scm_from_long(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_all__SWIG_11 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-all"
  size_t arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  size_t result;
  
  {
    arg1 = (size_t) scm_to_ulong(argv[0]);
  }
  result = meep::sum_to_all(arg1);
  {
    gswig_result = scm_from_ulong(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_partial_sum_to_all__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-partial-sum-to-all"
  size_t arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  size_t result;
  
  {
    arg1 = (size_t) scm_to_ulong(argv[0]);
  }
  result = meep::partial_sum_to_all(arg1);
  {
    gswig_result = scm_from_ulong(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_partial_sum_to_all(SCM rest)
{
#define FUNC_NAME "meep-partial-sum-to-all"
  SCM argv[1];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 1, "meep-partial-sum-to-all");
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_partial_sum_to_all__SWIG_0(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_partial_sum_to_all__SWIG_1(argc,argv);
    }
  }
  
  scm_misc_error("meep-partial-sum-to-all", "No matching method for generic function `meep_partial_sum_to_all'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_all__SWIG_12 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-all"
  size_t *arg1 = (size_t *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (size_t *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_size_t, 1, 0);
  }
  {
    arg2 = (size_t *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_size_t, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::sum_to_all((size_t const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_all(SCM rest)
{
#define FUNC_NAME "meep-sum-to-all"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-sum-to-all");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_long_double, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_sum_to_all__SWIG_7(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_long_double_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_sum_to_all__SWIG_9(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_sum_to_all__SWIG_10(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_sum_to_all__SWIG_11(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_sum_to_all__SWIG_0(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = SwigComplex_Check(argv[0]);
    }
    if (_v) {
      return _wrap_meep_sum_to_all__SWIG_8(argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_float_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_std__complexT_float_t, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_sum_to_all__SWIG_6(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_sum_to_all__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_sum_to_all__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_sum_to_all__SWIG_3(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_float_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_sum_to_all__SWIG_4(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_sum_to_all__SWIG_5(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_size_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_size_t, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_sum_to_all__SWIG_12(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-sum-to-all", "No matching method for generic function `meep_sum_to_all'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_master__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-sum-to-master"
  size_t *arg1 = (size_t *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (size_t *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_size_t, 1, 0);
  }
  {
    arg2 = (size_t *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_size_t, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::sum_to_master((size_t const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_sum_to_master(SCM rest)
{
#define FUNC_NAME "meep-sum-to-master"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-sum-to-master");
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_sum_to_master__SWIG_0(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_sum_to_master__SWIG_1(argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_sum_to_master__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_sum_to_master__SWIG_3(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_float_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_std__complexT_float_t, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_sum_to_master__SWIG_4(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_sum_to_master__SWIG_5(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_size_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_size_t, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_sum_to_master__SWIG_6(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-sum-to-master", "No matching method for generic function `meep_sum_to_master'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_or_to_all__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-or-to-all"
  bool arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (bool) scm_is_true(argv[0]);
  }
  result = (bool)meep::or_to_all(arg1);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_or_to_all__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-or-to-all"
  int *arg1 = (int *) 0 ;
  int *arg2 = (int *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (int *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_int, 1, 0);
  }
  {
    arg2 = (int *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_int, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::or_to_all((int const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_or_to_all(SCM rest)
{
#define FUNC_NAME "meep-or-to-all"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-or-to-all");
  if (argc == 1) {
    int _v;
    {
      _v = SCM_BOOLP(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_or_to_all__SWIG_0(argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_or_to_all__SWIG_1(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-or-to-all", "No matching method for generic function `meep_or_to_all'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_bw_or_to_all (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-bw-or-to-all"
  size_t *arg1 = (size_t *) 0 ;
  size_t *arg2 = (size_t *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (size_t *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_size_t, 1, 0);
  }
  {
    arg2 = (size_t *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_size_t, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(s_2);
  }
  meep::bw_or_to_all((size_t const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_and_to_all__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-and-to-all"
  bool arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (bool) scm_is_true(argv[0]);
  }
  result = (bool)meep::and_to_all(arg1);
  {
    gswig_result = scm_from_bool(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_and_to_all__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-and-to-all"
  int *arg1 = (int *) 0 ;
  int *arg2 = (int *) 0 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (int *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_int, 1, 0);
  }
  {
    arg2 = (int *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_int, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  meep::and_to_all((int const *)arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_and_to_all(SCM rest)
{
#define FUNC_NAME "meep-and-to-all"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-and-to-all");
  if (argc == 1) {
    int _v;
    {
      _v = SCM_BOOLP(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_and_to_all__SWIG_0(argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_int, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_and_to_all__SWIG_1(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-and-to-all", "No matching method for generic function `meep_and_to_all'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_master_printf (SCM s_0)
{
#define FUNC_NAME "meep-master-printf"
  char *arg1 = (char *) 0 ;
  void *arg2 = 0 ;
  int must_free1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (char *)SWIG_scm2str(s_0);
    must_free1 = 1;
  }
  meep::master_printf((char const *)arg1,arg2);
  gswig_result = SCM_UNSPECIFIED;
  if (must_free1 && arg1) SWIG_free(arg1);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_master_printf_stderr (SCM s_0)
{
#define FUNC_NAME "meep-master-printf-stderr"
  char *arg1 = (char *) 0 ;
  void *arg2 = 0 ;
  int must_free1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (char *)SWIG_scm2str(s_0);
    must_free1 = 1;
  }
  meep::master_printf_stderr((char const *)arg1,arg2);
  gswig_result = SCM_UNSPECIFIED;
  if (must_free1 && arg1) SWIG_free(arg1);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_debug_printf (SCM s_0)
{
#define FUNC_NAME "meep-debug-printf"
  char *arg1 = (char *) 0 ;
  void *arg2 = 0 ;
  int must_free1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (char *)SWIG_scm2str(s_0);
    must_free1 = 1;
  }
  meep::debug_printf((char const *)arg1,arg2);
  gswig_result = SCM_UNSPECIFIED;
  if (must_free1 && arg1) SWIG_free(arg1);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_master_fprintf (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-master-fprintf"
  FILE *arg1 = (FILE *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (FILE *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_FILE, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  meep::master_fprintf(arg1,(char const *)arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_master_fopen (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-master-fopen"
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free1 = 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  FILE *result = 0 ;
  
  {
    arg1 = (char *)SWIG_scm2str(s_0);
    must_free1 = 1;
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  result = (FILE *)meep::master_fopen((char const *)arg1,(char const *)arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_FILE, 0);
  }
  if (must_free1 && arg1) SWIG_free(arg1);
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_master_fclose (SCM s_0)
{
#define FUNC_NAME "meep-master-fclose"
  FILE *arg1 = (FILE *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (FILE *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_FILE, 1, 0);
  }
  meep::master_fclose(arg1);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_set_meep_printf_callback (SCM s_0)
{
#define FUNC_NAME "meep-set-meep-printf-callback"
  meep::meep_printf_callback_func arg1 = (meep::meep_printf_callback_func) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::meep_printf_callback_func result;
  
  {
    arg1 = (meep::meep_printf_callback_func)SWIG_MustGetPtr(s_0, SWIGTYPE_p_f_p_q_const__char__void, 1, 0);
  }
  result = (meep::meep_printf_callback_func)meep::set_meep_printf_callback(arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_f_p_q_const__char__void, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_set_meep_printf_stderr_callback (SCM s_0)
{
#define FUNC_NAME "meep-set-meep-printf-stderr-callback"
  meep::meep_printf_callback_func arg1 = (meep::meep_printf_callback_func) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::meep_printf_callback_func result;
  
  {
    arg1 = (meep::meep_printf_callback_func)SWIG_MustGetPtr(s_0, SWIGTYPE_p_f_p_q_const__char__void, 1, 0);
  }
  result = (meep::meep_printf_callback_func)meep::set_meep_printf_stderr_callback(arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_f_p_q_const__char__void, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_begin_critical_section (SCM s_0)
{
#define FUNC_NAME "meep-begin-critical-section"
  int arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (int) scm_to_int(s_0);
  }
  meep::begin_critical_section(arg1);
  gswig_result = SCM_UNSPECIFIED;
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_end_critical_section (SCM s_0)
{
#define FUNC_NAME "meep-end-critical-section"
  int arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (int) scm_to_int(s_0);
  }
  meep::end_critical_section(arg1);
  gswig_result = SCM_UNSPECIFIED;
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_divide_parallel_processes (SCM s_0)
{
#define FUNC_NAME "meep-divide-parallel-processes"
  int arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (int) scm_to_int(s_0);
  }
  result = (int)meep::divide_parallel_processes(arg1);
  {
    gswig_result = scm_from_long(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_begin_global_communications ()
{
#define FUNC_NAME "meep-begin-global-communications"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  meep::begin_global_communications();
  gswig_result = SCM_UNSPECIFIED;
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_end_global_communications ()
{
#define FUNC_NAME "meep-end-global-communications"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  meep::end_global_communications();
  gswig_result = SCM_UNSPECIFIED;
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_end_divide_parallel ()
{
#define FUNC_NAME "meep-end-divide-parallel"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  meep::end_divide_parallel();
  gswig_result = SCM_UNSPECIFIED;
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_my_global_rank ()
{
#define FUNC_NAME "meep-my-global-rank"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  result = (int)meep::my_global_rank();
  {
    gswig_result = scm_from_long(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_MEEP_MIN_OUTPUT_TIME(SCM s_0)
{
#define FUNC_NAME "MEEP-MIN-OUTPUT-TIME"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_double(gswig_const_MEEP_MIN_OUTPUT_TIME);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_verbosity(SCM s_0)
{
#define FUNC_NAME "verbosity"
  SCM gswig_result;
  
  if (s_0 != SCM_UNDEFINED) {
    {
      meep::verbosity = (int) scm_to_int(s_0);
    }
  }
  {
    gswig_result = scm_from_long(meep::verbosity);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_pi(SCM s_0)
{
#define FUNC_NAME "pi"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_double(meep::pi);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_infinity(SCM s_0)
{
#define FUNC_NAME "infinity"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_double(meep::infinity);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_nan(SCM s_0)
{
#define FUNC_NAME "nan"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_double(meep::nan);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_cdouble__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-cdouble"
  std::complex< float > arg1 ;
  std::complex< float > *argp1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    argp1 = (std::complex< float > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_float_t, 1, 0);
    arg1 = *argp1;
  }
  result = meep::cdouble(arg1);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_cdouble__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-cdouble"
  std::complex< double > arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[0]);
    arg1 = std::complex<double>(cnum.re, cnum.im);
  }
  result = meep::cdouble(arg1);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_cdouble(SCM rest)
{
#define FUNC_NAME "meep-cdouble"
  SCM argv[1];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 1, "meep-cdouble");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_float_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_cdouble__SWIG_0(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = SwigComplex_Check(argv[0]);
    }
    if (_v) {
      return _wrap_meep_cdouble__SWIG_1(argc,argv);
    }
  }
  
  scm_misc_error("meep-cdouble", "No matching method for generic function `meep_cdouble'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_matrix_invert (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-matrix-invert"
  std::complex< double > (*arg1)[9] = 0 ;
  std::complex< double > (*arg2)[9] = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (std::complex< double > (*)[9])SWIG_MustGetPtr(s_0, SWIGTYPE_p_a_9__std__complexT_double_t, 1, 0);
  }
  {
    arg2 = (std::complex< double > (*)[9])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_9__std__complexT_double_t, 2, 0);
  }
  meep::matrix_invert((std::complex< double > (&)[9])*arg1,(std::complex< double > (&)[9])*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_linspace (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-linspace"
  double arg1 ;
  double arg2 ;
  size_t arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< double > result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  {
    arg3 = (size_t) scm_to_ulong(s_2);
  }
  result = meep::linspace(arg1,arg2,arg3);
  {
    std::vector< double > * resultptr;
    resultptr = new std::vector< double >((const std::vector< double > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_double_t, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_pml_quadratic_profile (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-pml-quadratic-profile"
  double arg1 ;
  void *arg2 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  {
    arg2 = (void *)SWIG_MustGetPtr(s_1, NULL, 2, 0);
  }
  result = (double)meep::pml_quadratic_profile(arg1,arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_susceptibility__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-susceptibility"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::susceptibility *result = 0 ;
  
  result = (meep::susceptibility *)new meep::susceptibility();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__susceptibility, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_susceptibility__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-susceptibility"
  meep::susceptibility *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::susceptibility *result = 0 ;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  result = (meep::susceptibility *)new meep::susceptibility((meep::susceptibility const &)*arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__susceptibility, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_susceptibility(SCM rest)
{
#define FUNC_NAME "new-meep-susceptibility"
  SCM argv[1];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 1, "new-meep-susceptibility");
  if (argc == 0) {
    return _wrap_new_meep_susceptibility__SWIG_0(argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__susceptibility, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_susceptibility__SWIG_1(argc,argv);
    }
  }
  
  scm_misc_error("new-meep-susceptibility", "No matching method for generic function `new_meep_susceptibility'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_clone (SCM s_0)
{
#define FUNC_NAME "meep-susceptibility-clone"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::susceptibility *result = 0 ;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  result = (meep::susceptibility *)((meep::susceptibility const *)arg1)->clone();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__susceptibility, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_susceptibility (SCM s_0)
{
#define FUNC_NAME "delete-meep-susceptibility"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_get_id (SCM s_0)
{
#define FUNC_NAME "meep-susceptibility-get-id"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  result = (int)((meep::susceptibility const *)arg1)->get_id();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_chi1__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-susceptibility-chi1"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  meep::realnum arg2 ;
  meep::realnum arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > result;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum) scm_to_double(argv[1]);
  }
  {
    arg3 = (meep::realnum) scm_to_double(argv[2]);
  }
  result = (arg1)->chi1(arg2,arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_chi1__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-susceptibility-chi1"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  meep::realnum arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > result;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum) scm_to_double(argv[1]);
  }
  result = (arg1)->chi1(arg2);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_chi1(SCM rest)
{
#define FUNC_NAME "meep-susceptibility-chi1"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-susceptibility-chi1");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__susceptibility, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_susceptibility_chi1__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__susceptibility, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_susceptibility_chi1__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-susceptibility-chi1", "No matching method for generic function `meep_susceptibility_chi1'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_update_P (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5)
{
#define FUNC_NAME "meep-susceptibility-update-P"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  meep::realnum *(*arg2)[2] ;
  meep::realnum *(*arg3)[2] ;
  meep::realnum arg4 ;
  meep::grid_volume *arg5 = 0 ;
  void *arg6 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_2__p_double, 2, 0);
  }
  {
    arg3 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_2, SWIGTYPE_p_a_2__p_double, 3, 0);
  }
  {
    arg4 = (meep::realnum) scm_to_double(s_3);
  }
  {
    arg5 = (meep::grid_volume *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_meep__grid_volume, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(s_5, NULL, 6, 0);
  }
  ((meep::susceptibility const *)arg1)->update_P((meep::realnum *(*)[2])arg2,(meep::realnum *(*)[2])arg3,arg4,(meep::grid_volume const &)*arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_subtract_P (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-susceptibility-subtract-P"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  meep::field_type arg2 ;
  meep::realnum *(*arg3)[2] ;
  void *arg4 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (meep::field_type) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_2, SWIGTYPE_p_a_2__p_double, 3, 0);
  }
  {
    arg4 = (void *)SWIG_MustGetPtr(s_3, NULL, 4, 0);
  }
  ((meep::susceptibility const *)arg1)->subtract_P(arg2,(meep::realnum *(*)[2])arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_needs_P (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-susceptibility-needs-P"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  meep::component arg2 ;
  int arg3 ;
  meep::realnum *(*arg4)[2] ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (int) scm_to_int(s_2);
  }
  {
    arg4 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_3, SWIGTYPE_p_a_2__p_double, 4, 0);
  }
  result = (bool)((meep::susceptibility const *)arg1)->needs_P(arg2,arg3,(meep::realnum *(*)[2])arg4);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_needs_W_notowned (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-susceptibility-needs-W-notowned"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  meep::component arg2 ;
  meep::realnum *(*arg3)[2] ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_2, SWIGTYPE_p_a_2__p_double, 3, 0);
  }
  result = (bool)((meep::susceptibility const *)arg1)->needs_W_notowned(arg2,(meep::realnum *(*)[2])arg3);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_needs_W_prev (SCM s_0)
{
#define FUNC_NAME "meep-susceptibility-needs-W-prev"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  result = (bool)((meep::susceptibility const *)arg1)->needs_W_prev();
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_new_internal_data (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-susceptibility-new-internal-data"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  meep::realnum *(*arg2)[2] ;
  meep::grid_volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_2__p_double, 2, 0);
  }
  {
    arg3 = (meep::grid_volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__grid_volume, 3, 0);
  }
  result = (void *)((meep::susceptibility const *)arg1)->new_internal_data((meep::realnum *(*)[2])arg2,(meep::grid_volume const &)*arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_delete_internal_data (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-susceptibility-delete-internal-data"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  void *arg2 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (void *)SWIG_MustGetPtr(s_1, NULL, 2, 0);
  }
  ((meep::susceptibility const *)arg1)->delete_internal_data(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_init_internal_data (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4)
{
#define FUNC_NAME "meep-susceptibility-init-internal-data"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  meep::realnum *(*arg2)[2] ;
  meep::realnum arg3 ;
  meep::grid_volume *arg4 = 0 ;
  void *arg5 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_2__p_double, 2, 0);
  }
  {
    arg3 = (meep::realnum) scm_to_double(s_2);
  }
  {
    arg4 = (meep::grid_volume *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__grid_volume, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(s_4, NULL, 5, 0);
  }
  ((meep::susceptibility const *)arg1)->init_internal_data((meep::realnum *(*)[2])arg2,arg3,(meep::grid_volume const &)*arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_copy_internal_data (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-susceptibility-copy-internal-data"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  void *arg2 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (void *)SWIG_MustGetPtr(s_1, NULL, 2, 0);
  }
  result = (void *)((meep::susceptibility const *)arg1)->copy_internal_data(arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_num_internal_notowned_needed (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-susceptibility-num-internal-notowned-needed"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  meep::component arg2 ;
  void *arg3 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (void *)SWIG_MustGetPtr(s_2, NULL, 3, 0);
  }
  result = (int)((meep::susceptibility const *)arg1)->num_internal_notowned_needed(arg2,arg3);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_internal_notowned_ptr (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4)
{
#define FUNC_NAME "meep-susceptibility-internal-notowned-ptr"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  int arg2 ;
  meep::component arg3 ;
  int arg4 ;
  void *arg5 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  {
    arg3 = (meep::component) scm_to_int(s_2); 
  }
  {
    arg4 = (int) scm_to_int(s_3);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(s_4, NULL, 5, 0);
  }
  result = (meep::realnum *)((meep::susceptibility const *)arg1)->internal_notowned_ptr(arg2,arg3,arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_num_cinternal_notowned_needed (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-susceptibility-num-cinternal-notowned-needed"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  meep::component arg2 ;
  void *arg3 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (void *)SWIG_MustGetPtr(s_2, NULL, 3, 0);
  }
  result = (int)((meep::susceptibility const *)arg1)->num_cinternal_notowned_needed(arg2,arg3);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_cinternal_notowned_ptr (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5)
{
#define FUNC_NAME "meep-susceptibility-cinternal-notowned-ptr"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  int arg2 ;
  meep::component arg3 ;
  int arg4 ;
  int arg5 ;
  void *arg6 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  {
    arg3 = (meep::component) scm_to_int(s_2); 
  }
  {
    arg4 = (int) scm_to_int(s_3);
  }
  {
    arg5 = (int) scm_to_int(s_4);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(s_5, NULL, 6, 0);
  }
  result = (meep::realnum *)((meep::susceptibility const *)arg1)->cinternal_notowned_ptr(arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_dump_params (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-susceptibility-dump-params"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_size_t, 3, 0);
  }
  (arg1)->dump_params(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_get_num_params (SCM s_0)
{
#define FUNC_NAME "meep-susceptibility-get-num-params"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  result = (int)(arg1)->get_num_params();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_set_id (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-susceptibility-set-id"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  (arg1)->set_id(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_next_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-susceptibility-next-set"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  meep::susceptibility *arg2 = (meep::susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (meep::susceptibility *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__susceptibility, 2, 0);
  }
  if (arg1) (arg1)->next = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_next_get (SCM s_0)
{
#define FUNC_NAME "meep-susceptibility-next-get"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::susceptibility *result = 0 ;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  result = (meep::susceptibility *) ((arg1)->next);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__susceptibility, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_ntot_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-susceptibility-ntot-set"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  size_t arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (size_t) scm_to_ulong(s_1);
  }
  if (arg1) (arg1)->ntot = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_ntot_get (SCM s_0)
{
#define FUNC_NAME "meep-susceptibility-ntot-get"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  size_t result;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  result =  ((arg1)->ntot);
  {
    gswig_result = scm_from_ulong(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_sigma_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-susceptibility-sigma-set"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  meep::realnum *(*arg2)[5] ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[5])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_5__p_double, 2, 0);
  }
  {
    meep::realnum * (*inp)[5] = (meep::realnum * (*)[5])(arg2);
    meep::realnum * (*dest)[5] = (meep::realnum * (*)[5])(arg1->sigma);
    size_t ii = 0;
    for (; ii < meep::NUM_FIELD_COMPONENTS; ++ii) {
      meep::realnum * *ip = inp[ii];
      meep::realnum * *dp = dest[ii];
      size_t jj = 0;
      for (; jj < 5; ++jj) dp[jj] = ip[jj];
    }
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_sigma_get (SCM s_0)
{
#define FUNC_NAME "meep-susceptibility-sigma-get"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *(*result)[5] = 0 ;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  result = (meep::realnum *(*)[5])(meep::realnum *(*)[5]) ((arg1)->sigma);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_a_5__p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_trivial_sigma_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-susceptibility-trivial-sigma-set"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  bool (*arg2)[5] ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  {
    arg2 = (bool (*)[5])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_5__bool, 2, 0);
  }
  {
    bool (*inp)[5] = (bool (*)[5])(arg2);
    bool (*dest)[5] = (bool (*)[5])(arg1->trivial_sigma);
    size_t ii = 0;
    for (; ii < meep::NUM_FIELD_COMPONENTS; ++ii) {
      bool *ip = inp[ii];
      bool *dp = dest[ii];
      size_t jj = 0;
      for (; jj < 5; ++jj) dp[jj] = ip[jj];
    }
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_susceptibility_trivial_sigma_get (SCM s_0)
{
#define FUNC_NAME "meep-susceptibility-trivial-sigma-get"
  meep::susceptibility *arg1 = (meep::susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool (*result)[5] = 0 ;
  
  {
    arg1 = (meep::susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__susceptibility, 1, 0);
  }
  result = (bool (*)[5])(bool (*)[5]) ((arg1)->trivial_sigma);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_a_5__bool, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_lorentzian_susceptibility__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-lorentzian-susceptibility"
  meep::realnum arg1 ;
  meep::realnum arg2 ;
  bool arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::lorentzian_susceptibility *result = 0 ;
  
  {
    arg1 = (meep::realnum) scm_to_double(argv[0]);
  }
  {
    arg2 = (meep::realnum) scm_to_double(argv[1]);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  result = (meep::lorentzian_susceptibility *)new meep::lorentzian_susceptibility(arg1,arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__lorentzian_susceptibility, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_lorentzian_susceptibility__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-lorentzian-susceptibility"
  meep::realnum arg1 ;
  meep::realnum arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::lorentzian_susceptibility *result = 0 ;
  
  {
    arg1 = (meep::realnum) scm_to_double(argv[0]);
  }
  {
    arg2 = (meep::realnum) scm_to_double(argv[1]);
  }
  result = (meep::lorentzian_susceptibility *)new meep::lorentzian_susceptibility(arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__lorentzian_susceptibility, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_lorentzian_susceptibility(SCM rest)
{
#define FUNC_NAME "new-meep-lorentzian-susceptibility"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "new-meep-lorentzian-susceptibility");
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_new_meep_lorentzian_susceptibility__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_new_meep_lorentzian_susceptibility__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("new-meep-lorentzian-susceptibility", "No matching method for generic function `new_meep_lorentzian_susceptibility'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_lorentzian_susceptibility_clone (SCM s_0)
{
#define FUNC_NAME "meep-lorentzian-susceptibility-clone"
  meep::lorentzian_susceptibility *arg1 = (meep::lorentzian_susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::susceptibility *result = 0 ;
  
  {
    arg1 = (meep::lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__lorentzian_susceptibility, 1, 0);
  }
  result = (meep::susceptibility *)((meep::lorentzian_susceptibility const *)arg1)->clone();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__susceptibility, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_lorentzian_susceptibility (SCM s_0)
{
#define FUNC_NAME "delete-meep-lorentzian-susceptibility"
  meep::lorentzian_susceptibility *arg1 = (meep::lorentzian_susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__lorentzian_susceptibility, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_lorentzian_susceptibility_chi1__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-lorentzian-susceptibility-chi1"
  meep::lorentzian_susceptibility *arg1 = (meep::lorentzian_susceptibility *) 0 ;
  meep::realnum arg2 ;
  meep::realnum arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > result;
  
  {
    arg1 = (meep::lorentzian_susceptibility *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__lorentzian_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum) scm_to_double(argv[1]);
  }
  {
    arg3 = (meep::realnum) scm_to_double(argv[2]);
  }
  result = (arg1)->chi1(arg2,arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_lorentzian_susceptibility_chi1__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-lorentzian-susceptibility-chi1"
  meep::lorentzian_susceptibility *arg1 = (meep::lorentzian_susceptibility *) 0 ;
  meep::realnum arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > result;
  
  {
    arg1 = (meep::lorentzian_susceptibility *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__lorentzian_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum) scm_to_double(argv[1]);
  }
  result = (arg1)->chi1(arg2);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_lorentzian_susceptibility_chi1(SCM rest)
{
#define FUNC_NAME "meep-lorentzian-susceptibility-chi1"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-lorentzian-susceptibility-chi1");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__lorentzian_susceptibility, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_lorentzian_susceptibility_chi1__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__lorentzian_susceptibility, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_lorentzian_susceptibility_chi1__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-lorentzian-susceptibility-chi1", "No matching method for generic function `meep_lorentzian_susceptibility_chi1'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_lorentzian_susceptibility_update_P (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5)
{
#define FUNC_NAME "meep-lorentzian-susceptibility-update-P"
  meep::lorentzian_susceptibility *arg1 = (meep::lorentzian_susceptibility *) 0 ;
  meep::realnum *(*arg2)[2] ;
  meep::realnum *(*arg3)[2] ;
  meep::realnum arg4 ;
  meep::grid_volume *arg5 = 0 ;
  void *arg6 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__lorentzian_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_2__p_double, 2, 0);
  }
  {
    arg3 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_2, SWIGTYPE_p_a_2__p_double, 3, 0);
  }
  {
    arg4 = (meep::realnum) scm_to_double(s_3);
  }
  {
    arg5 = (meep::grid_volume *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_meep__grid_volume, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(s_5, NULL, 6, 0);
  }
  ((meep::lorentzian_susceptibility const *)arg1)->update_P((meep::realnum *(*)[2])arg2,(meep::realnum *(*)[2])arg3,arg4,(meep::grid_volume const &)*arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_lorentzian_susceptibility_subtract_P (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-lorentzian-susceptibility-subtract-P"
  meep::lorentzian_susceptibility *arg1 = (meep::lorentzian_susceptibility *) 0 ;
  meep::field_type arg2 ;
  meep::realnum *(*arg3)[2] ;
  void *arg4 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__lorentzian_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::field_type) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_2, SWIGTYPE_p_a_2__p_double, 3, 0);
  }
  {
    arg4 = (void *)SWIG_MustGetPtr(s_3, NULL, 4, 0);
  }
  ((meep::lorentzian_susceptibility const *)arg1)->subtract_P(arg2,(meep::realnum *(*)[2])arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_lorentzian_susceptibility_new_internal_data (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-lorentzian-susceptibility-new-internal-data"
  meep::lorentzian_susceptibility *arg1 = (meep::lorentzian_susceptibility *) 0 ;
  meep::realnum *(*arg2)[2] ;
  meep::grid_volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__lorentzian_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_2__p_double, 2, 0);
  }
  {
    arg3 = (meep::grid_volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__grid_volume, 3, 0);
  }
  result = (void *)((meep::lorentzian_susceptibility const *)arg1)->new_internal_data((meep::realnum *(*)[2])arg2,(meep::grid_volume const &)*arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_lorentzian_susceptibility_init_internal_data (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4)
{
#define FUNC_NAME "meep-lorentzian-susceptibility-init-internal-data"
  meep::lorentzian_susceptibility *arg1 = (meep::lorentzian_susceptibility *) 0 ;
  meep::realnum *(*arg2)[2] ;
  meep::realnum arg3 ;
  meep::grid_volume *arg4 = 0 ;
  void *arg5 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__lorentzian_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_2__p_double, 2, 0);
  }
  {
    arg3 = (meep::realnum) scm_to_double(s_2);
  }
  {
    arg4 = (meep::grid_volume *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__grid_volume, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(s_4, NULL, 5, 0);
  }
  ((meep::lorentzian_susceptibility const *)arg1)->init_internal_data((meep::realnum *(*)[2])arg2,arg3,(meep::grid_volume const &)*arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_lorentzian_susceptibility_copy_internal_data (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-lorentzian-susceptibility-copy-internal-data"
  meep::lorentzian_susceptibility *arg1 = (meep::lorentzian_susceptibility *) 0 ;
  void *arg2 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__lorentzian_susceptibility, 1, 0);
  }
  {
    arg2 = (void *)SWIG_MustGetPtr(s_1, NULL, 2, 0);
  }
  result = (void *)((meep::lorentzian_susceptibility const *)arg1)->copy_internal_data(arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_lorentzian_susceptibility_num_cinternal_notowned_needed (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-lorentzian-susceptibility-num-cinternal-notowned-needed"
  meep::lorentzian_susceptibility *arg1 = (meep::lorentzian_susceptibility *) 0 ;
  meep::component arg2 ;
  void *arg3 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__lorentzian_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (void *)SWIG_MustGetPtr(s_2, NULL, 3, 0);
  }
  result = (int)((meep::lorentzian_susceptibility const *)arg1)->num_cinternal_notowned_needed(arg2,arg3);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_lorentzian_susceptibility_cinternal_notowned_ptr (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5)
{
#define FUNC_NAME "meep-lorentzian-susceptibility-cinternal-notowned-ptr"
  meep::lorentzian_susceptibility *arg1 = (meep::lorentzian_susceptibility *) 0 ;
  int arg2 ;
  meep::component arg3 ;
  int arg4 ;
  int arg5 ;
  void *arg6 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__lorentzian_susceptibility, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  {
    arg3 = (meep::component) scm_to_int(s_2); 
  }
  {
    arg4 = (int) scm_to_int(s_3);
  }
  {
    arg5 = (int) scm_to_int(s_4);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(s_5, NULL, 6, 0);
  }
  result = (meep::realnum *)((meep::lorentzian_susceptibility const *)arg1)->cinternal_notowned_ptr(arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_lorentzian_susceptibility_dump_params (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-lorentzian-susceptibility-dump-params"
  meep::lorentzian_susceptibility *arg1 = (meep::lorentzian_susceptibility *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__lorentzian_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_size_t, 3, 0);
  }
  (arg1)->dump_params(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_lorentzian_susceptibility_get_num_params (SCM s_0)
{
#define FUNC_NAME "meep-lorentzian-susceptibility-get-num-params"
  meep::lorentzian_susceptibility *arg1 = (meep::lorentzian_susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__lorentzian_susceptibility, 1, 0);
  }
  result = (int)(arg1)->get_num_params();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_noisy_lorentzian_susceptibility__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-noisy-lorentzian-susceptibility"
  meep::realnum arg1 ;
  meep::realnum arg2 ;
  meep::realnum arg3 ;
  bool arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::noisy_lorentzian_susceptibility *result = 0 ;
  
  {
    arg1 = (meep::realnum) scm_to_double(argv[0]);
  }
  {
    arg2 = (meep::realnum) scm_to_double(argv[1]);
  }
  {
    arg3 = (meep::realnum) scm_to_double(argv[2]);
  }
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  result = (meep::noisy_lorentzian_susceptibility *)new meep::noisy_lorentzian_susceptibility(arg1,arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__noisy_lorentzian_susceptibility, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_noisy_lorentzian_susceptibility__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-noisy-lorentzian-susceptibility"
  meep::realnum arg1 ;
  meep::realnum arg2 ;
  meep::realnum arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::noisy_lorentzian_susceptibility *result = 0 ;
  
  {
    arg1 = (meep::realnum) scm_to_double(argv[0]);
  }
  {
    arg2 = (meep::realnum) scm_to_double(argv[1]);
  }
  {
    arg3 = (meep::realnum) scm_to_double(argv[2]);
  }
  result = (meep::noisy_lorentzian_susceptibility *)new meep::noisy_lorentzian_susceptibility(arg1,arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__noisy_lorentzian_susceptibility, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_noisy_lorentzian_susceptibility(SCM rest)
{
#define FUNC_NAME "new-meep-noisy-lorentzian-susceptibility"
  SCM argv[4];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 4, "new-meep-noisy-lorentzian-susceptibility");
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_new_meep_noisy_lorentzian_susceptibility__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_new_meep_noisy_lorentzian_susceptibility__SWIG_0(argc,argv);
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-noisy-lorentzian-susceptibility", "No matching method for generic function `new_meep_noisy_lorentzian_susceptibility'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_noisy_lorentzian_susceptibility_clone (SCM s_0)
{
#define FUNC_NAME "meep-noisy-lorentzian-susceptibility-clone"
  meep::noisy_lorentzian_susceptibility *arg1 = (meep::noisy_lorentzian_susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::susceptibility *result = 0 ;
  
  {
    arg1 = (meep::noisy_lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__noisy_lorentzian_susceptibility, 1, 0);
  }
  result = (meep::susceptibility *)((meep::noisy_lorentzian_susceptibility const *)arg1)->clone();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__susceptibility, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_noisy_lorentzian_susceptibility_update_P (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5)
{
#define FUNC_NAME "meep-noisy-lorentzian-susceptibility-update-P"
  meep::noisy_lorentzian_susceptibility *arg1 = (meep::noisy_lorentzian_susceptibility *) 0 ;
  meep::realnum *(*arg2)[2] ;
  meep::realnum *(*arg3)[2] ;
  meep::realnum arg4 ;
  meep::grid_volume *arg5 = 0 ;
  void *arg6 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::noisy_lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__noisy_lorentzian_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_2__p_double, 2, 0);
  }
  {
    arg3 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_2, SWIGTYPE_p_a_2__p_double, 3, 0);
  }
  {
    arg4 = (meep::realnum) scm_to_double(s_3);
  }
  {
    arg5 = (meep::grid_volume *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_meep__grid_volume, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(s_5, NULL, 6, 0);
  }
  ((meep::noisy_lorentzian_susceptibility const *)arg1)->update_P((meep::realnum *(*)[2])arg2,(meep::realnum *(*)[2])arg3,arg4,(meep::grid_volume const &)*arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_noisy_lorentzian_susceptibility_dump_params (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-noisy-lorentzian-susceptibility-dump-params"
  meep::noisy_lorentzian_susceptibility *arg1 = (meep::noisy_lorentzian_susceptibility *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::noisy_lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__noisy_lorentzian_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_size_t, 3, 0);
  }
  (arg1)->dump_params(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_noisy_lorentzian_susceptibility_get_num_params (SCM s_0)
{
#define FUNC_NAME "meep-noisy-lorentzian-susceptibility-get-num-params"
  meep::noisy_lorentzian_susceptibility *arg1 = (meep::noisy_lorentzian_susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::noisy_lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__noisy_lorentzian_susceptibility, 1, 0);
  }
  result = (int)(arg1)->get_num_params();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_noisy_lorentzian_susceptibility (SCM s_0)
{
#define FUNC_NAME "delete-meep-noisy-lorentzian-susceptibility"
  meep::noisy_lorentzian_susceptibility *arg1 = (meep::noisy_lorentzian_susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::noisy_lorentzian_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__noisy_lorentzian_susceptibility, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_GYROTROPIC_LORENTZIAN(SCM s_0)
{
#define FUNC_NAME "GYROTROPIC-LORENTZIAN"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_GYROTROPIC_LORENTZIAN);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_GYROTROPIC_DRUDE(SCM s_0)
{
#define FUNC_NAME "GYROTROPIC-DRUDE"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_GYROTROPIC_DRUDE);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_GYROTROPIC_SATURATED(SCM s_0)
{
#define FUNC_NAME "GYROTROPIC-SATURATED"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_GYROTROPIC_SATURATED);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_gyrotropic_susceptibility__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-gyrotropic-susceptibility"
  meep::vec *arg1 = 0 ;
  meep::realnum arg2 ;
  meep::realnum arg3 ;
  meep::realnum arg4 ;
  meep::gyrotropy_model arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::gyrotropic_susceptibility *result = 0 ;
  
  
  meep::vec vec__arg1 = vector3_to_vec(ctl_convert_vector3_to_c(argv[0]));
  arg1 = &vec__arg1;
  
  {
    arg2 = (meep::realnum) scm_to_double(argv[1]);
  }
  {
    arg3 = (meep::realnum) scm_to_double(argv[2]);
  }
  {
    arg4 = (meep::realnum) scm_to_double(argv[3]);
  }
  {
    arg5 = (meep::gyrotropy_model) scm_to_int(argv[4]); 
  }
  result = (meep::gyrotropic_susceptibility *)new meep::gyrotropic_susceptibility((meep::vec const &)*arg1,arg2,arg3,arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_gyrotropic_susceptibility__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-gyrotropic-susceptibility"
  meep::vec *arg1 = 0 ;
  meep::realnum arg2 ;
  meep::realnum arg3 ;
  meep::realnum arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::gyrotropic_susceptibility *result = 0 ;
  
  
  meep::vec vec__arg1 = vector3_to_vec(ctl_convert_vector3_to_c(argv[0]));
  arg1 = &vec__arg1;
  
  {
    arg2 = (meep::realnum) scm_to_double(argv[1]);
  }
  {
    arg3 = (meep::realnum) scm_to_double(argv[2]);
  }
  {
    arg4 = (meep::realnum) scm_to_double(argv[3]);
  }
  result = (meep::gyrotropic_susceptibility *)new meep::gyrotropic_susceptibility((meep::vec const &)*arg1,arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_gyrotropic_susceptibility__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-gyrotropic-susceptibility"
  meep::vec *arg1 = 0 ;
  meep::realnum arg2 ;
  meep::realnum arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::gyrotropic_susceptibility *result = 0 ;
  
  
  meep::vec vec__arg1 = vector3_to_vec(ctl_convert_vector3_to_c(argv[0]));
  arg1 = &vec__arg1;
  
  {
    arg2 = (meep::realnum) scm_to_double(argv[1]);
  }
  {
    arg3 = (meep::realnum) scm_to_double(argv[2]);
  }
  result = (meep::gyrotropic_susceptibility *)new meep::gyrotropic_susceptibility((meep::vec const &)*arg1,arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_gyrotropic_susceptibility(SCM rest)
{
#define FUNC_NAME "new-meep-gyrotropic-susceptibility"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "new-meep-gyrotropic-susceptibility");
  if (argc == 3) {
    int _v;
    {
      _v = SwigVector3_Check(argv[0]);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_new_meep_gyrotropic_susceptibility__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = SwigVector3_Check(argv[0]);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            return _wrap_new_meep_gyrotropic_susceptibility__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = SwigVector3_Check(argv[0]);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_new_meep_gyrotropic_susceptibility__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-gyrotropic-susceptibility", "No matching method for generic function `new_meep_gyrotropic_susceptibility'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_gyrotropic_susceptibility_clone (SCM s_0)
{
#define FUNC_NAME "meep-gyrotropic-susceptibility-clone"
  meep::gyrotropic_susceptibility *arg1 = (meep::gyrotropic_susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::susceptibility *result = 0 ;
  
  {
    arg1 = (meep::gyrotropic_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1, 0);
  }
  result = (meep::susceptibility *)((meep::gyrotropic_susceptibility const *)arg1)->clone();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__susceptibility, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gyrotropic_susceptibility_new_internal_data (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-gyrotropic-susceptibility-new-internal-data"
  meep::gyrotropic_susceptibility *arg1 = (meep::gyrotropic_susceptibility *) 0 ;
  meep::realnum *(*arg2)[2] ;
  meep::grid_volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::gyrotropic_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_2__p_double, 2, 0);
  }
  {
    arg3 = (meep::grid_volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__grid_volume, 3, 0);
  }
  result = (void *)((meep::gyrotropic_susceptibility const *)arg1)->new_internal_data((meep::realnum *(*)[2])arg2,(meep::grid_volume const &)*arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gyrotropic_susceptibility_init_internal_data (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4)
{
#define FUNC_NAME "meep-gyrotropic-susceptibility-init-internal-data"
  meep::gyrotropic_susceptibility *arg1 = (meep::gyrotropic_susceptibility *) 0 ;
  meep::realnum *(*arg2)[2] ;
  meep::realnum arg3 ;
  meep::grid_volume *arg4 = 0 ;
  void *arg5 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::gyrotropic_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_2__p_double, 2, 0);
  }
  {
    arg3 = (meep::realnum) scm_to_double(s_2);
  }
  {
    arg4 = (meep::grid_volume *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__grid_volume, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(s_4, NULL, 5, 0);
  }
  ((meep::gyrotropic_susceptibility const *)arg1)->init_internal_data((meep::realnum *(*)[2])arg2,arg3,(meep::grid_volume const &)*arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gyrotropic_susceptibility_copy_internal_data (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-gyrotropic-susceptibility-copy-internal-data"
  meep::gyrotropic_susceptibility *arg1 = (meep::gyrotropic_susceptibility *) 0 ;
  void *arg2 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::gyrotropic_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1, 0);
  }
  {
    arg2 = (void *)SWIG_MustGetPtr(s_1, NULL, 2, 0);
  }
  result = (void *)((meep::gyrotropic_susceptibility const *)arg1)->copy_internal_data(arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gyrotropic_susceptibility_needs_P (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-gyrotropic-susceptibility-needs-P"
  meep::gyrotropic_susceptibility *arg1 = (meep::gyrotropic_susceptibility *) 0 ;
  meep::component arg2 ;
  int arg3 ;
  meep::realnum *(*arg4)[2] ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::gyrotropic_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (int) scm_to_int(s_2);
  }
  {
    arg4 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_3, SWIGTYPE_p_a_2__p_double, 4, 0);
  }
  result = (bool)((meep::gyrotropic_susceptibility const *)arg1)->needs_P(arg2,arg3,(meep::realnum *(*)[2])arg4);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gyrotropic_susceptibility_update_P (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5)
{
#define FUNC_NAME "meep-gyrotropic-susceptibility-update-P"
  meep::gyrotropic_susceptibility *arg1 = (meep::gyrotropic_susceptibility *) 0 ;
  meep::realnum *(*arg2)[2] ;
  meep::realnum *(*arg3)[2] ;
  meep::realnum arg4 ;
  meep::grid_volume *arg5 = 0 ;
  void *arg6 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::gyrotropic_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_2__p_double, 2, 0);
  }
  {
    arg3 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_2, SWIGTYPE_p_a_2__p_double, 3, 0);
  }
  {
    arg4 = (meep::realnum) scm_to_double(s_3);
  }
  {
    arg5 = (meep::grid_volume *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_meep__grid_volume, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(s_5, NULL, 6, 0);
  }
  ((meep::gyrotropic_susceptibility const *)arg1)->update_P((meep::realnum *(*)[2])arg2,(meep::realnum *(*)[2])arg3,arg4,(meep::grid_volume const &)*arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gyrotropic_susceptibility_subtract_P (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-gyrotropic-susceptibility-subtract-P"
  meep::gyrotropic_susceptibility *arg1 = (meep::gyrotropic_susceptibility *) 0 ;
  meep::field_type arg2 ;
  meep::realnum *(*arg3)[2] ;
  void *arg4 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::gyrotropic_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::field_type) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_2, SWIGTYPE_p_a_2__p_double, 3, 0);
  }
  {
    arg4 = (void *)SWIG_MustGetPtr(s_3, NULL, 4, 0);
  }
  ((meep::gyrotropic_susceptibility const *)arg1)->subtract_P(arg2,(meep::realnum *(*)[2])arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gyrotropic_susceptibility_num_cinternal_notowned_needed (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-gyrotropic-susceptibility-num-cinternal-notowned-needed"
  meep::gyrotropic_susceptibility *arg1 = (meep::gyrotropic_susceptibility *) 0 ;
  meep::component arg2 ;
  void *arg3 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::gyrotropic_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (void *)SWIG_MustGetPtr(s_2, NULL, 3, 0);
  }
  result = (int)((meep::gyrotropic_susceptibility const *)arg1)->num_cinternal_notowned_needed(arg2,arg3);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gyrotropic_susceptibility_cinternal_notowned_ptr (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5)
{
#define FUNC_NAME "meep-gyrotropic-susceptibility-cinternal-notowned-ptr"
  meep::gyrotropic_susceptibility *arg1 = (meep::gyrotropic_susceptibility *) 0 ;
  int arg2 ;
  meep::component arg3 ;
  int arg4 ;
  int arg5 ;
  void *arg6 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::gyrotropic_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  {
    arg3 = (meep::component) scm_to_int(s_2); 
  }
  {
    arg4 = (int) scm_to_int(s_3);
  }
  {
    arg5 = (int) scm_to_int(s_4);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(s_5, NULL, 6, 0);
  }
  result = (meep::realnum *)((meep::gyrotropic_susceptibility const *)arg1)->cinternal_notowned_ptr(arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gyrotropic_susceptibility_dump_params (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-gyrotropic-susceptibility-dump-params"
  meep::gyrotropic_susceptibility *arg1 = (meep::gyrotropic_susceptibility *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  size_t *arg3 = (size_t *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::gyrotropic_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_size_t, 3, 0);
  }
  (arg1)->dump_params(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gyrotropic_susceptibility_get_num_params (SCM s_0)
{
#define FUNC_NAME "meep-gyrotropic-susceptibility-get-num-params"
  meep::gyrotropic_susceptibility *arg1 = (meep::gyrotropic_susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::gyrotropic_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1, 0);
  }
  result = (int)(arg1)->get_num_params();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gyrotropic_susceptibility_needs_W_notowned (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-gyrotropic-susceptibility-needs-W-notowned"
  meep::gyrotropic_susceptibility *arg1 = (meep::gyrotropic_susceptibility *) 0 ;
  meep::component arg2 ;
  meep::realnum *(*arg3)[2] ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::gyrotropic_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_2, SWIGTYPE_p_a_2__p_double, 3, 0);
  }
  result = (bool)((meep::gyrotropic_susceptibility const *)arg1)->needs_W_notowned(arg2,(meep::realnum *(*)[2])arg3);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_gyrotropic_susceptibility (SCM s_0)
{
#define FUNC_NAME "delete-meep-gyrotropic-susceptibility"
  meep::gyrotropic_susceptibility *arg1 = (meep::gyrotropic_susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::gyrotropic_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gyrotropic_susceptibility, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_multilevel_susceptibility__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-multilevel-susceptibility"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::multilevel_susceptibility *result = 0 ;
  
  result = (meep::multilevel_susceptibility *)new meep::multilevel_susceptibility();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__multilevel_susceptibility, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_multilevel_susceptibility__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-multilevel-susceptibility"
  int arg1 ;
  int arg2 ;
  meep::realnum *arg3 = (meep::realnum *) 0 ;
  meep::realnum *arg4 = (meep::realnum *) 0 ;
  meep::realnum *arg5 = (meep::realnum *) 0 ;
  meep::realnum *arg6 = (meep::realnum *) 0 ;
  meep::realnum *arg7 = (meep::realnum *) 0 ;
  meep::realnum *arg8 = (meep::realnum *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::multilevel_susceptibility *result = 0 ;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (meep::realnum *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (meep::realnum *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (meep::realnum *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_double, 5, 0);
  }
  {
    arg6 = (meep::realnum *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_double, 6, 0);
  }
  {
    arg7 = (meep::realnum *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_double, 7, 0);
  }
  {
    arg8 = (meep::realnum *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_double, 8, 0);
  }
  result = (meep::multilevel_susceptibility *)new meep::multilevel_susceptibility(arg1,arg2,(meep::realnum const *)arg3,(meep::realnum const *)arg4,(meep::realnum const *)arg5,(meep::realnum const *)arg6,(meep::realnum const *)arg7,(meep::realnum const *)arg8);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__multilevel_susceptibility, 1);
  }
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_multilevel_susceptibility__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-multilevel-susceptibility"
  meep::multilevel_susceptibility *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::multilevel_susceptibility *result = 0 ;
  
  {
    arg1 = (meep::multilevel_susceptibility *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__multilevel_susceptibility, 1, 0);
  }
  result = (meep::multilevel_susceptibility *)new meep::multilevel_susceptibility((meep::multilevel_susceptibility const &)*arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__multilevel_susceptibility, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_multilevel_susceptibility(SCM rest)
{
#define FUNC_NAME "new-meep-multilevel-susceptibility"
  SCM argv[8];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 8, "new-meep-multilevel-susceptibility");
  if (argc == 0) {
    return _wrap_new_meep_multilevel_susceptibility__SWIG_0(argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__multilevel_susceptibility, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_multilevel_susceptibility__SWIG_2(argc,argv);
    }
  }
  if (argc == 8) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_meep_multilevel_susceptibility__SWIG_1(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-multilevel-susceptibility", "No matching method for generic function `new_meep_multilevel_susceptibility'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_multilevel_susceptibility_clone (SCM s_0)
{
#define FUNC_NAME "meep-multilevel-susceptibility-clone"
  meep::multilevel_susceptibility *arg1 = (meep::multilevel_susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::susceptibility *result = 0 ;
  
  {
    arg1 = (meep::multilevel_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__multilevel_susceptibility, 1, 0);
  }
  result = (meep::susceptibility *)((meep::multilevel_susceptibility const *)arg1)->clone();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__susceptibility, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_multilevel_susceptibility (SCM s_0)
{
#define FUNC_NAME "delete-meep-multilevel-susceptibility"
  meep::multilevel_susceptibility *arg1 = (meep::multilevel_susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::multilevel_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__multilevel_susceptibility, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_multilevel_susceptibility_update_P (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5)
{
#define FUNC_NAME "meep-multilevel-susceptibility-update-P"
  meep::multilevel_susceptibility *arg1 = (meep::multilevel_susceptibility *) 0 ;
  meep::realnum *(*arg2)[2] ;
  meep::realnum *(*arg3)[2] ;
  meep::realnum arg4 ;
  meep::grid_volume *arg5 = 0 ;
  void *arg6 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::multilevel_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__multilevel_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_2__p_double, 2, 0);
  }
  {
    arg3 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_2, SWIGTYPE_p_a_2__p_double, 3, 0);
  }
  {
    arg4 = (meep::realnum) scm_to_double(s_3);
  }
  {
    arg5 = (meep::grid_volume *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_meep__grid_volume, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(s_5, NULL, 6, 0);
  }
  ((meep::multilevel_susceptibility const *)arg1)->update_P((meep::realnum *(*)[2])arg2,(meep::realnum *(*)[2])arg3,arg4,(meep::grid_volume const &)*arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_multilevel_susceptibility_subtract_P (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-multilevel-susceptibility-subtract-P"
  meep::multilevel_susceptibility *arg1 = (meep::multilevel_susceptibility *) 0 ;
  meep::field_type arg2 ;
  meep::realnum *(*arg3)[2] ;
  void *arg4 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::multilevel_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__multilevel_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::field_type) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_2, SWIGTYPE_p_a_2__p_double, 3, 0);
  }
  {
    arg4 = (void *)SWIG_MustGetPtr(s_3, NULL, 4, 0);
  }
  ((meep::multilevel_susceptibility const *)arg1)->subtract_P(arg2,(meep::realnum *(*)[2])arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_multilevel_susceptibility_new_internal_data (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-multilevel-susceptibility-new-internal-data"
  meep::multilevel_susceptibility *arg1 = (meep::multilevel_susceptibility *) 0 ;
  meep::realnum *(*arg2)[2] ;
  meep::grid_volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::multilevel_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__multilevel_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_2__p_double, 2, 0);
  }
  {
    arg3 = (meep::grid_volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__grid_volume, 3, 0);
  }
  result = (void *)((meep::multilevel_susceptibility const *)arg1)->new_internal_data((meep::realnum *(*)[2])arg2,(meep::grid_volume const &)*arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_multilevel_susceptibility_init_internal_data (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4)
{
#define FUNC_NAME "meep-multilevel-susceptibility-init-internal-data"
  meep::multilevel_susceptibility *arg1 = (meep::multilevel_susceptibility *) 0 ;
  meep::realnum *(*arg2)[2] ;
  meep::realnum arg3 ;
  meep::grid_volume *arg4 = 0 ;
  void *arg5 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::multilevel_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__multilevel_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_2__p_double, 2, 0);
  }
  {
    arg3 = (meep::realnum) scm_to_double(s_2);
  }
  {
    arg4 = (meep::grid_volume *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__grid_volume, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(s_4, NULL, 5, 0);
  }
  ((meep::multilevel_susceptibility const *)arg1)->init_internal_data((meep::realnum *(*)[2])arg2,arg3,(meep::grid_volume const &)*arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_multilevel_susceptibility_copy_internal_data (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-multilevel-susceptibility-copy-internal-data"
  meep::multilevel_susceptibility *arg1 = (meep::multilevel_susceptibility *) 0 ;
  void *arg2 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::multilevel_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__multilevel_susceptibility, 1, 0);
  }
  {
    arg2 = (void *)SWIG_MustGetPtr(s_1, NULL, 2, 0);
  }
  result = (void *)((meep::multilevel_susceptibility const *)arg1)->copy_internal_data(arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_multilevel_susceptibility_delete_internal_data (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-multilevel-susceptibility-delete-internal-data"
  meep::multilevel_susceptibility *arg1 = (meep::multilevel_susceptibility *) 0 ;
  void *arg2 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::multilevel_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__multilevel_susceptibility, 1, 0);
  }
  {
    arg2 = (void *)SWIG_MustGetPtr(s_1, NULL, 2, 0);
  }
  ((meep::multilevel_susceptibility const *)arg1)->delete_internal_data(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_multilevel_susceptibility_num_cinternal_notowned_needed (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-multilevel-susceptibility-num-cinternal-notowned-needed"
  meep::multilevel_susceptibility *arg1 = (meep::multilevel_susceptibility *) 0 ;
  meep::component arg2 ;
  void *arg3 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::multilevel_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__multilevel_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (void *)SWIG_MustGetPtr(s_2, NULL, 3, 0);
  }
  result = (int)((meep::multilevel_susceptibility const *)arg1)->num_cinternal_notowned_needed(arg2,arg3);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_multilevel_susceptibility_cinternal_notowned_ptr (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5)
{
#define FUNC_NAME "meep-multilevel-susceptibility-cinternal-notowned-ptr"
  meep::multilevel_susceptibility *arg1 = (meep::multilevel_susceptibility *) 0 ;
  int arg2 ;
  meep::component arg3 ;
  int arg4 ;
  int arg5 ;
  void *arg6 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::multilevel_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__multilevel_susceptibility, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  {
    arg3 = (meep::component) scm_to_int(s_2); 
  }
  {
    arg4 = (int) scm_to_int(s_3);
  }
  {
    arg5 = (int) scm_to_int(s_4);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(s_5, NULL, 6, 0);
  }
  result = (meep::realnum *)((meep::multilevel_susceptibility const *)arg1)->cinternal_notowned_ptr(arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_multilevel_susceptibility_needs_W_notowned (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-multilevel-susceptibility-needs-W-notowned"
  meep::multilevel_susceptibility *arg1 = (meep::multilevel_susceptibility *) 0 ;
  meep::component arg2 ;
  meep::realnum *(*arg3)[2] ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::multilevel_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__multilevel_susceptibility, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::realnum *(*)[2])SWIG_MustGetPtr(s_2, SWIGTYPE_p_a_2__p_double, 3, 0);
  }
  result = (bool)((meep::multilevel_susceptibility const *)arg1)->needs_W_notowned(arg2,(meep::realnum *(*)[2])arg3);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_multilevel_susceptibility_needs_W_prev (SCM s_0)
{
#define FUNC_NAME "meep-multilevel-susceptibility-needs-W-prev"
  meep::multilevel_susceptibility *arg1 = (meep::multilevel_susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::multilevel_susceptibility *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__multilevel_susceptibility, 1, 0);
  }
  result = (bool)((meep::multilevel_susceptibility const *)arg1)->needs_W_prev();
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_READONLY(SCM s_0)
{
#define FUNC_NAME "meep-h5file-READONLY"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_h5file_READONLY);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_READWRITE(SCM s_0)
{
#define FUNC_NAME "meep-h5file-READWRITE"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_h5file_READWRITE);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_WRITE(SCM s_0)
{
#define FUNC_NAME "meep-h5file-WRITE"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_h5file_WRITE);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_h5file__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-h5file"
  char *arg1 = (char *) 0 ;
  meep::h5file::access_mode arg2 ;
  bool arg3 ;
  bool arg4 ;
  int must_free1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::h5file *result = 0 ;
  
  {
    arg1 = (char *)SWIG_scm2str(argv[0]);
    must_free1 = 1;
  }
  {
    arg2 = (meep::h5file::access_mode) scm_to_int(argv[1]); 
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  result = (meep::h5file *)new meep::h5file((char const *)arg1,arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__h5file, 1);
  }
  if (must_free1 && arg1) SWIG_free(arg1);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_h5file__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-h5file"
  char *arg1 = (char *) 0 ;
  meep::h5file::access_mode arg2 ;
  bool arg3 ;
  int must_free1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::h5file *result = 0 ;
  
  {
    arg1 = (char *)SWIG_scm2str(argv[0]);
    must_free1 = 1;
  }
  {
    arg2 = (meep::h5file::access_mode) scm_to_int(argv[1]); 
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  result = (meep::h5file *)new meep::h5file((char const *)arg1,arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__h5file, 1);
  }
  if (must_free1 && arg1) SWIG_free(arg1);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_h5file__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-h5file"
  char *arg1 = (char *) 0 ;
  meep::h5file::access_mode arg2 ;
  int must_free1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::h5file *result = 0 ;
  
  {
    arg1 = (char *)SWIG_scm2str(argv[0]);
    must_free1 = 1;
  }
  {
    arg2 = (meep::h5file::access_mode) scm_to_int(argv[1]); 
  }
  result = (meep::h5file *)new meep::h5file((char const *)arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__h5file, 1);
  }
  if (must_free1 && arg1) SWIG_free(arg1);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_h5file__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-h5file"
  char *arg1 = (char *) 0 ;
  int must_free1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::h5file *result = 0 ;
  
  {
    arg1 = (char *)SWIG_scm2str(argv[0]);
    must_free1 = 1;
  }
  result = (meep::h5file *)new meep::h5file((char const *)arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__h5file, 1);
  }
  if (must_free1 && arg1) SWIG_free(arg1);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_h5file(SCM rest)
{
#define FUNC_NAME "new-meep-h5file"
  SCM argv[4];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 4, "new-meep-h5file");
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_string(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_new_meep_h5file__SWIG_3(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_string(argv[0]) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_new_meep_h5file__SWIG_2(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_string(argv[0]) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_new_meep_h5file__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = scm_is_string(argv[0]) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_new_meep_h5file__SWIG_0(argc,argv);
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-h5file", "No matching method for generic function `new_meep_h5file'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_h5file (SCM s_0)
{
#define FUNC_NAME "delete-meep-h5file"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__h5file, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_ok (SCM s_0)
{
#define FUNC_NAME "meep-h5file-ok"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__h5file, 1, 0);
  }
  result = (bool)(arg1)->ok();
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_read__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-read"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int *arg3 = (int *) 0 ;
  size_t *arg4 = (size_t *) 0 ;
  int arg5 ;
  bool arg6 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_int, 3, 0);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = (void *)(arg1)->read((char const *)arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_read__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-read"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int *arg3 = (int *) 0 ;
  size_t *arg4 = (size_t *) 0 ;
  int arg5 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_int, 3, 0);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (void *)(arg1)->read((char const *)arg2,arg3,arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_write__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-write"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  void *arg5 = (void *) 0 ;
  bool arg6 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(argv[4], NULL, 5, 0);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  (arg1)->write((char const *)arg2,arg3,(size_t const *)arg4,arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_write__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-write"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  void *arg5 = (void *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(argv[4], NULL, 5, 0);
  }
  (arg1)->write((char const *)arg2,arg3,(size_t const *)arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_read__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-read"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  result = (char *)(arg1)->read((char const *)arg2);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_read(SCM rest)
{
#define FUNC_NAME "meep-h5file-read"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "meep-h5file-read");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_h5file_read__SWIG_2(argc,argv);
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_int, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_h5file_read__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_int, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_h5file_read__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-h5file-read", "No matching method for generic function `meep_h5file_read'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_write__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-write"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int must_free2 = 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->write((char const *)arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_write(SCM rest)
{
#define FUNC_NAME "meep-h5file-write"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "meep-h5file-write");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_h5file_write__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_h5file_write__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_h5file_write__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-h5file-write", "No matching method for generic function `meep_h5file_write'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_create_data__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-create-data"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  bool arg5 ;
  bool arg6 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  (arg1)->create_data((char const *)arg2,arg3,(size_t const *)arg4,arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_create_data__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-create-data"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  bool arg5 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  (arg1)->create_data((char const *)arg2,arg3,(size_t const *)arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_create_data__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-create-data"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  (arg1)->create_data((char const *)arg2,arg3,(size_t const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_create_data(SCM rest)
{
#define FUNC_NAME "meep-h5file-create-data"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "meep-h5file-create-data");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_h5file_create_data__SWIG_2(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_h5file_create_data__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_h5file_create_data__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-h5file-create-data", "No matching method for generic function `meep_h5file_create_data'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_extend_data (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-h5file-extend-data"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(s_2);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_size_t, 4, 0);
  }
  (arg1)->extend_data((char const *)arg2,arg3,(size_t const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_create_or_extend_data__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-create-or-extend-data"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  bool arg5 ;
  bool arg6 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  (arg1)->create_or_extend_data((char const *)arg2,arg3,(size_t const *)arg4,arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_create_or_extend_data__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-create-or-extend-data"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  bool arg5 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  (arg1)->create_or_extend_data((char const *)arg2,arg3,(size_t const *)arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_create_or_extend_data(SCM rest)
{
#define FUNC_NAME "meep-h5file-create-or-extend-data"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "meep-h5file-create-or-extend-data");
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_h5file_create_or_extend_data__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_h5file_create_or_extend_data__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-h5file-create-or-extend-data", "No matching method for generic function `meep_h5file_create_or_extend_data'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_write_chunk__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-write-chunk"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  int arg2 ;
  size_t *arg3 = (size_t *) 0 ;
  size_t *arg4 = (size_t *) 0 ;
  float *arg5 = (float *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_size_t, 3, 0);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (float *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_float, 5, 0);
  }
  (arg1)->write_chunk(arg2,(size_t const *)arg3,(size_t const *)arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_write_chunk__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-write-chunk"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  int arg2 ;
  size_t *arg3 = (size_t *) 0 ;
  size_t *arg4 = (size_t *) 0 ;
  double *arg5 = (double *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_size_t, 3, 0);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (double *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_double, 5, 0);
  }
  (arg1)->write_chunk(arg2,(size_t const *)arg3,(size_t const *)arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_write_chunk__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-write-chunk"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  int arg2 ;
  size_t *arg3 = (size_t *) 0 ;
  size_t *arg4 = (size_t *) 0 ;
  size_t *arg5 = (size_t *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_size_t, 3, 0);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (size_t *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_size_t, 5, 0);
  }
  (arg1)->write_chunk(arg2,(size_t const *)arg3,(size_t const *)arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_write_chunk(SCM rest)
{
#define FUNC_NAME "meep-h5file-write-chunk"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-h5file-write-chunk");
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_size_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_float, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_h5file_write_chunk__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_size_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_h5file_write_chunk__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_size_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_size_t, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_h5file_write_chunk__SWIG_2(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-h5file-write-chunk", "No matching method for generic function `meep_h5file_write_chunk'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_done_writing_chunks (SCM s_0)
{
#define FUNC_NAME "meep-h5file-done-writing-chunks"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__h5file, 1, 0);
  }
  (arg1)->done_writing_chunks();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_read_size (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4)
{
#define FUNC_NAME "meep-h5file-read-size"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int *arg3 = (int *) 0 ;
  size_t *arg4 = (size_t *) 0 ;
  int arg5 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  {
    arg3 = (int *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_int, 3, 0);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(s_4);
  }
  (arg1)->read_size((char const *)arg2,arg3,arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_read_chunk__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-read-chunk"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  int arg2 ;
  size_t *arg3 = (size_t *) 0 ;
  size_t *arg4 = (size_t *) 0 ;
  float *arg5 = (float *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_size_t, 3, 0);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (float *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_float, 5, 0);
  }
  (arg1)->read_chunk(arg2,(size_t const *)arg3,(size_t const *)arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_read_chunk__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-read-chunk"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  int arg2 ;
  size_t *arg3 = (size_t *) 0 ;
  size_t *arg4 = (size_t *) 0 ;
  double *arg5 = (double *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_size_t, 3, 0);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (double *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_double, 5, 0);
  }
  (arg1)->read_chunk(arg2,(size_t const *)arg3,(size_t const *)arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_read_chunk__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-h5file-read-chunk"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  int arg2 ;
  size_t *arg3 = (size_t *) 0 ;
  size_t *arg4 = (size_t *) 0 ;
  size_t *arg5 = (size_t *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_size_t, 3, 0);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (size_t *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_size_t, 5, 0);
  }
  (arg1)->read_chunk(arg2,(size_t const *)arg3,(size_t const *)arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_read_chunk(SCM rest)
{
#define FUNC_NAME "meep-h5file-read-chunk"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-h5file-read-chunk");
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_size_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_float, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_h5file_read_chunk__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_size_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_h5file_read_chunk__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__h5file, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_size_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_size_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_size_t, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_h5file_read_chunk__SWIG_2(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-h5file-read-chunk", "No matching method for generic function `meep_h5file_read_chunk'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_remove (SCM s_0)
{
#define FUNC_NAME "meep-h5file-remove"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__h5file, 1, 0);
  }
  (arg1)->remove();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_remove_data (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-h5file-remove-data"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  (arg1)->remove_data((char const *)arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_file_name (SCM s_0)
{
#define FUNC_NAME "meep-h5file-file-name"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__h5file, 1, 0);
  }
  result = (char *)((meep::h5file const *)arg1)->file_name();
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_prevent_deadlock (SCM s_0)
{
#define FUNC_NAME "meep-h5file-prevent-deadlock"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__h5file, 1, 0);
  }
  (arg1)->prevent_deadlock();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_dataset_exists (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-h5file-dataset-exists"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  result = (bool)(arg1)->dataset_exists((char const *)arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_extending_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-h5file-extending-set"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  meep::h5file::extending_s *arg2 = (meep::h5file::extending_s *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (meep::h5file::extending_s *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__h5file__extending_s, 2, 0);
  }
  if (arg1) (arg1)->extending = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_extending_get (SCM s_0)
{
#define FUNC_NAME "meep-h5file-extending-get"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::h5file::extending_s *result = 0 ;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__h5file, 1, 0);
  }
  result = (meep::h5file::extending_s *) ((arg1)->extending);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__h5file__extending_s, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_h5file_get_extending (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-h5file-get-extending"
  meep::h5file *arg1 = (meep::h5file *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::h5file::extending_s *result = 0 ;
  
  {
    arg1 = (meep::h5file *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__h5file, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  result = (meep::h5file::extending_s *)((meep::h5file const *)arg1)->get_extending((char const *)arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__h5file__extending_s, 0);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_DEFAULT_SUBPIXEL_TOL(SCM s_0)
{
#define FUNC_NAME "DEFAULT-SUBPIXEL-TOL"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_double(gswig_const_DEFAULT_SUBPIXEL_TOL);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_DEFAULT_SUBPIXEL_MAXEVAL(SCM s_0)
{
#define FUNC_NAME "DEFAULT-SUBPIXEL-MAXEVAL"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_DEFAULT_SUBPIXEL_MAXEVAL);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_material_function ()
{
#define FUNC_NAME "new-meep-material-function"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::material_function *result = 0 ;
  
  result = (meep::material_function *)new meep::material_function();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__material_function, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_material_function (SCM s_0)
{
#define FUNC_NAME "delete-meep-material-function"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_set_volume (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-material-function-set-volume"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  (arg1)->set_volume((meep::volume const &)*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_unset_volume (SCM s_0)
{
#define FUNC_NAME "meep-material-function-unset-volume"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  (arg1)->unset_volume();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_chi1p1 (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-material-function-chi1p1"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::field_type arg2 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  {
    arg2 = (meep::field_type) scm_to_int(s_1); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(s_2));
  arg3 = &vec__arg3;
  
  result = (double)(arg1)->chi1p1(arg2,(meep::vec const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_eps (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-material-function-eps"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(s_1));
  arg2 = &vec__arg2;
  
  result = (double)(arg1)->eps((meep::vec const &)*arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_has_mu (SCM s_0)
{
#define FUNC_NAME "meep-material-function-has-mu"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  result = (bool)(arg1)->has_mu();
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_mu (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-material-function-mu"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(s_1));
  arg2 = &vec__arg2;
  
  result = (double)(arg1)->mu((meep::vec const &)*arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_has_conductivity (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-material-function-has-conductivity"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = (bool)(arg1)->has_conductivity(arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_conductivity (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-material-function-conductivity"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::component arg2 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(s_2));
  arg3 = &vec__arg3;
  
  result = (double)(arg1)->conductivity(arg2,(meep::vec const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_normal_vector (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-material-function-normal-vector"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::field_type arg2 ;
  meep::volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  {
    arg2 = (meep::field_type) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__volume, 3, 0);
  }
  result = (arg1)->normal_vector(arg2,(meep::volume const &)*arg3);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_eff_chi1inv_row__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-material-function-eff-chi1inv-row"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::component arg2 ;
  double *arg3 ;
  meep::volume *arg4 = 0 ;
  double arg5 ;
  int arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__material_function, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  (arg1)->eff_chi1inv_row(arg2,arg3,(meep::volume const &)*arg4,arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_eff_chi1inv_row__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-material-function-eff-chi1inv-row"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::component arg2 ;
  double *arg3 ;
  meep::volume *arg4 = 0 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__material_function, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  (arg1)->eff_chi1inv_row(arg2,arg3,(meep::volume const &)*arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_eff_chi1inv_row__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-material-function-eff-chi1inv-row"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::component arg2 ;
  double *arg3 ;
  meep::volume *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__material_function, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
  }
  (arg1)->eff_chi1inv_row(arg2,arg3,(meep::volume const &)*arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_eff_chi1inv_row(SCM rest)
{
#define FUNC_NAME "meep-material-function-eff-chi1inv-row"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "meep-material-function-eff-chi1inv-row");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__material_function, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_material_function_eff_chi1inv_row__SWIG_2(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__material_function, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_material_function_eff_chi1inv_row__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__material_function, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_material_function_eff_chi1inv_row__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-material-function-eff-chi1inv-row", "No matching method for generic function `meep_material_function_eff_chi1inv_row'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_sigma_row (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-material-function-sigma-row"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::component arg2 ;
  double *arg3 ;
  meep::vec *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_double, 3, 0);
  }
  
  meep::vec vec__arg4 = vector3_to_vec(ctl_convert_vector3_to_c(s_3));
  arg4 = &vec__arg4;
  
  (arg1)->sigma_row(arg2,arg3,(meep::vec const &)*arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_has_chi3 (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-material-function-has-chi3"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = (bool)(arg1)->has_chi3(arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_chi3 (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-material-function-chi3"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::component arg2 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(s_2));
  arg3 = &vec__arg3;
  
  result = (double)(arg1)->chi3(arg2,(meep::vec const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_has_chi2 (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-material-function-has-chi2"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = (bool)(arg1)->has_chi2(arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_material_function_chi2 (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-material-function-chi2"
  meep::material_function *arg1 = (meep::material_function *) 0 ;
  meep::component arg2 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__material_function, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(s_2));
  arg3 = &vec__arg3;
  
  result = (double)(arg1)->chi2(arg2,(meep::vec const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_simple_material_function (SCM s_0)
{
#define FUNC_NAME "new-meep-simple-material-function"
  double (*arg1)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::simple_material_function *result = 0 ;
  
  {
    arg1 = (double (*)(meep::vec const &))SWIG_MustGetPtr(s_0, SWIGTYPE_p_f_r_q_const__meep__vec__double, 1, 0);
  }
  result = (meep::simple_material_function *)new meep::simple_material_function(arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__simple_material_function, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_simple_material_function (SCM s_0)
{
#define FUNC_NAME "delete-meep-simple-material-function"
  meep::simple_material_function *arg1 = (meep::simple_material_function *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::simple_material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__simple_material_function, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_simple_material_function_chi1p1 (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-simple-material-function-chi1p1"
  meep::simple_material_function *arg1 = (meep::simple_material_function *) 0 ;
  meep::field_type arg2 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::simple_material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__simple_material_function, 1, 0);
  }
  {
    arg2 = (meep::field_type) scm_to_int(s_1); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(s_2));
  arg3 = &vec__arg3;
  
  result = (double)(arg1)->chi1p1(arg2,(meep::vec const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_simple_material_function_eps (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-simple-material-function-eps"
  meep::simple_material_function *arg1 = (meep::simple_material_function *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::simple_material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__simple_material_function, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(s_1));
  arg2 = &vec__arg2;
  
  result = (double)(arg1)->eps((meep::vec const &)*arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_simple_material_function_mu (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-simple-material-function-mu"
  meep::simple_material_function *arg1 = (meep::simple_material_function *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::simple_material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__simple_material_function, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(s_1));
  arg2 = &vec__arg2;
  
  result = (double)(arg1)->mu((meep::vec const &)*arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_simple_material_function_conductivity (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-simple-material-function-conductivity"
  meep::simple_material_function *arg1 = (meep::simple_material_function *) 0 ;
  meep::component arg2 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::simple_material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__simple_material_function, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(s_2));
  arg3 = &vec__arg3;
  
  result = (double)(arg1)->conductivity(arg2,(meep::vec const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_simple_material_function_sigma_row (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-simple-material-function-sigma-row"
  meep::simple_material_function *arg1 = (meep::simple_material_function *) 0 ;
  meep::component arg2 ;
  double *arg3 ;
  meep::vec *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::simple_material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__simple_material_function, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_double, 3, 0);
  }
  
  meep::vec vec__arg4 = vector3_to_vec(ctl_convert_vector3_to_c(s_3));
  arg4 = &vec__arg4;
  
  (arg1)->sigma_row(arg2,arg3,(meep::vec const &)*arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_simple_material_function_chi3 (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-simple-material-function-chi3"
  meep::simple_material_function *arg1 = (meep::simple_material_function *) 0 ;
  meep::component arg2 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::simple_material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__simple_material_function, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(s_2));
  arg3 = &vec__arg3;
  
  result = (double)(arg1)->chi3(arg2,(meep::vec const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_simple_material_function_chi2 (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-simple-material-function-chi2"
  meep::simple_material_function *arg1 = (meep::simple_material_function *) 0 ;
  meep::component arg2 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::simple_material_function *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__simple_material_function, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(s_2));
  arg3 = &vec__arg3;
  
  result = (double)(arg1)->chi2(arg2,(meep::vec const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_a_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-a-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->a = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_a_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-a-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (double) ((arg1)->a);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_Courant_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-Courant-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->Courant = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_Courant_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-Courant-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (double) ((arg1)->Courant);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_dt_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-dt-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->dt = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_dt_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-dt-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (double) ((arg1)->dt);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_chi3_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-chi3-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::realnum **arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::realnum **)SWIG_MustGetPtr(s_1, SWIGTYPE_p_p_double, 2, 0);
  }
  {
    size_t ii;
    meep::realnum * *b = (meep::realnum * *) arg1->chi3;
    for (ii = 0; ii < (size_t)meep::NUM_FIELD_COMPONENTS; ii++) b[ii] = *((meep::realnum * *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_chi3_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-chi3-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum **result = 0 ;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (meep::realnum **)(meep::realnum **) ((arg1)->chi3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_chi2_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-chi2-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::realnum **arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::realnum **)SWIG_MustGetPtr(s_1, SWIGTYPE_p_p_double, 2, 0);
  }
  {
    size_t ii;
    meep::realnum * *b = (meep::realnum * *) arg1->chi2;
    for (ii = 0; ii < (size_t)meep::NUM_FIELD_COMPONENTS; ii++) b[ii] = *((meep::realnum * *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_chi2_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-chi2-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum **result = 0 ;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (meep::realnum **)(meep::realnum **) ((arg1)->chi2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_chi1inv_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-chi1inv-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::realnum *(*arg2)[5] ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[5])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_5__p_double, 2, 0);
  }
  {
    meep::realnum * (*inp)[5] = (meep::realnum * (*)[5])(arg2);
    meep::realnum * (*dest)[5] = (meep::realnum * (*)[5])(arg1->chi1inv);
    size_t ii = 0;
    for (; ii < meep::NUM_FIELD_COMPONENTS; ++ii) {
      meep::realnum * *ip = inp[ii];
      meep::realnum * *dp = dest[ii];
      size_t jj = 0;
      for (; jj < 5; ++jj) dp[jj] = ip[jj];
    }
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_chi1inv_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-chi1inv-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *(*result)[5] = 0 ;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (meep::realnum *(*)[5])(meep::realnum *(*)[5]) ((arg1)->chi1inv);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_a_5__p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_trivial_chi1inv_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-trivial-chi1inv-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  bool (*arg2)[5] ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (bool (*)[5])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_5__bool, 2, 0);
  }
  {
    bool (*inp)[5] = (bool (*)[5])(arg2);
    bool (*dest)[5] = (bool (*)[5])(arg1->trivial_chi1inv);
    size_t ii = 0;
    for (; ii < meep::NUM_FIELD_COMPONENTS; ++ii) {
      bool *ip = inp[ii];
      bool *dp = dest[ii];
      size_t jj = 0;
      for (; jj < 5; ++jj) dp[jj] = ip[jj];
    }
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_trivial_chi1inv_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-trivial-chi1inv-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool (*result)[5] = 0 ;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (bool (*)[5])(bool (*)[5]) ((arg1)->trivial_chi1inv);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_a_5__bool, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_conductivity_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-conductivity-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::realnum *(*arg2)[5] ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[5])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_5__p_double, 2, 0);
  }
  {
    meep::realnum * (*inp)[5] = (meep::realnum * (*)[5])(arg2);
    meep::realnum * (*dest)[5] = (meep::realnum * (*)[5])(arg1->conductivity);
    size_t ii = 0;
    for (; ii < meep::NUM_FIELD_COMPONENTS; ++ii) {
      meep::realnum * *ip = inp[ii];
      meep::realnum * *dp = dest[ii];
      size_t jj = 0;
      for (; jj < 5; ++jj) dp[jj] = ip[jj];
    }
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_conductivity_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-conductivity-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *(*result)[5] = 0 ;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (meep::realnum *(*)[5])(meep::realnum *(*)[5]) ((arg1)->conductivity);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_a_5__p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_condinv_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-condinv-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::realnum *(*arg2)[5] ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::realnum *(*)[5])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_5__p_double, 2, 0);
  }
  {
    meep::realnum * (*inp)[5] = (meep::realnum * (*)[5])(arg2);
    meep::realnum * (*dest)[5] = (meep::realnum * (*)[5])(arg1->condinv);
    size_t ii = 0;
    for (; ii < meep::NUM_FIELD_COMPONENTS; ++ii) {
      meep::realnum * *ip = inp[ii];
      meep::realnum * *dp = dest[ii];
      size_t jj = 0;
      for (; jj < 5; ++jj) dp[jj] = ip[jj];
    }
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_condinv_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-condinv-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *(*result)[5] = 0 ;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (meep::realnum *(*)[5])(meep::realnum *(*)[5]) ((arg1)->condinv);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_a_5__p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_condinv_stale_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-condinv-stale-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  bool arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (bool) scm_is_true(s_1);
  }
  if (arg1) (arg1)->condinv_stale = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_condinv_stale_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-condinv-stale-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (bool) ((arg1)->condinv_stale);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_sig_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-sig-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::realnum **arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::realnum **)SWIG_MustGetPtr(s_1, SWIGTYPE_p_p_double, 2, 0);
  }
  {
    size_t ii;
    meep::realnum * *b = (meep::realnum * *) arg1->sig;
    for (ii = 0; ii < (size_t)6; ii++) b[ii] = *((meep::realnum * *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_sig_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-sig-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum **result = 0 ;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (meep::realnum **)(meep::realnum **) ((arg1)->sig);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_kap_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-kap-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::realnum **arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::realnum **)SWIG_MustGetPtr(s_1, SWIGTYPE_p_p_double, 2, 0);
  }
  {
    size_t ii;
    meep::realnum * *b = (meep::realnum * *) arg1->kap;
    for (ii = 0; ii < (size_t)6; ii++) b[ii] = *((meep::realnum * *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_kap_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-kap-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum **result = 0 ;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (meep::realnum **)(meep::realnum **) ((arg1)->kap);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_siginv_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-siginv-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::realnum **arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::realnum **)SWIG_MustGetPtr(s_1, SWIGTYPE_p_p_double, 2, 0);
  }
  {
    size_t ii;
    meep::realnum * *b = (meep::realnum * *) arg1->siginv;
    for (ii = 0; ii < (size_t)6; ii++) b[ii] = *((meep::realnum * *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_siginv_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-siginv-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum **result = 0 ;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (meep::realnum **)(meep::realnum **) ((arg1)->siginv);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_sigsize_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-sigsize-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  int *arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (int *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_int, 2, 0);
  }
  {
    size_t ii;
    int *b = (int *) arg1->sigsize;
    for (ii = 0; ii < (size_t)6; ii++) b[ii] = *((int *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_sigsize_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-sigsize-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int *result = 0 ;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (int *)(int *) ((arg1)->sigsize);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_int, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_gv_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-gv-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::grid_volume *arg2 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  if (arg1) (arg1)->gv = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_gv_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-gv-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume *result = 0 ;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (meep::grid_volume *)& ((arg1)->gv);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__grid_volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_v_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-v-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::volume *arg2 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  if (arg1) (arg1)->v = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_v_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-v-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume *result = 0 ;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (meep::volume *)& ((arg1)->v);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_chiP_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-chiP-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::susceptibility **arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::susceptibility **)SWIG_MustGetPtr(s_1, SWIGTYPE_p_p_meep__susceptibility, 2, 0);
  }
  {
    size_t ii;
    meep::susceptibility * *b = (meep::susceptibility * *) arg1->chiP;
    for (ii = 0; ii < (size_t)meep::NUM_FIELD_TYPES; ii++) b[ii] = *((meep::susceptibility * *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_chiP_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-chiP-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::susceptibility **result = 0 ;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (meep::susceptibility **)(meep::susceptibility **) ((arg1)->chiP);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_p_meep__susceptibility, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_cost_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-cost-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->cost = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_cost_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-cost-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (double) ((arg1)->cost);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_refcount_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunk-refcount-set"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  if (arg1) (arg1)->refcount = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_refcount_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-refcount-get"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (int) ((arg1)->refcount);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_structure_chunk (SCM s_0)
{
#define FUNC_NAME "delete-meep-structure-chunk"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure_chunk__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure-chunk"
  meep::grid_volume *arg1 = 0 ;
  meep::volume *arg2 = 0 ;
  double arg3 ;
  int arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure_chunk *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  result = (meep::structure_chunk *)new meep::structure_chunk((meep::grid_volume const &)*arg1,(meep::volume const &)*arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure_chunk, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure_chunk__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure-chunk"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure_chunk *result = 0 ;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (meep::structure_chunk *)new meep::structure_chunk((meep::structure_chunk const *)arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure_chunk, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure_chunk(SCM rest)
{
#define FUNC_NAME "new-meep-structure-chunk"
  SCM argv[4];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 4, "new-meep-structure-chunk");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_structure_chunk__SWIG_1(argc,argv);
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            return _wrap_new_meep_structure_chunk__SWIG_0(argc,argv);
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-structure-chunk", "No matching method for generic function `new_meep_structure_chunk'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_set_chi1inv (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5)
{
#define FUNC_NAME "meep-structure-chunk-set-chi1inv"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::component arg2 ;
  meep::material_function *arg3 = 0 ;
  bool arg4 ;
  double arg5 ;
  int arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::material_function *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__material_function, 3, 0);
  }
  {
    arg4 = (bool) scm_is_true(s_3);
  }
  {
    arg5 = (double) scm_to_double(s_4);
  }
  {
    arg6 = (int) scm_to_int(s_5);
  }
  (arg1)->set_chi1inv(arg2,*arg3,arg4,arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_has_chi (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-structure-chunk-has-chi"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::direction) scm_to_int(s_2); 
  }
  result = (bool)((meep::structure_chunk const *)arg1)->has_chi(arg2,arg3);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_has_chisigma (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-structure-chunk-has-chisigma"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::direction) scm_to_int(s_2); 
  }
  result = (bool)((meep::structure_chunk const *)arg1)->has_chisigma(arg2,arg3);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_has_chi1inv (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-structure-chunk-has-chi1inv"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::direction) scm_to_int(s_2); 
  }
  result = (bool)((meep::structure_chunk const *)arg1)->has_chi1inv(arg2,arg3);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_set_conductivity (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-structure-chunk-set-conductivity"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::component arg2 ;
  meep::material_function *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::material_function *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__material_function, 3, 0);
  }
  (arg1)->set_conductivity(arg2,*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_update_condinv (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-update-condinv"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  (arg1)->update_condinv();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_set_chi3 (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-structure-chunk-set-chi3"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::component arg2 ;
  meep::material_function *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::material_function *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__material_function, 3, 0);
  }
  (arg1)->set_chi3(arg2,*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_set_chi2 (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-structure-chunk-set-chi2"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::component arg2 ;
  meep::material_function *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::material_function *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__material_function, 3, 0);
  }
  (arg1)->set_chi2(arg2,*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_use_pml (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5, SCM s_6, SCM s_7, SCM s_8, SCM s_9)
{
#define FUNC_NAME "meep-structure-chunk-use-pml"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::direction arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  meep::pml_profile_func arg7 = (meep::pml_profile_func) 0 ;
  void *arg8 = (void *) 0 ;
  double arg9 ;
  double arg10 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  {
    arg4 = (double) scm_to_double(s_3);
  }
  {
    arg5 = (double) scm_to_double(s_4);
  }
  {
    arg6 = (double) scm_to_double(s_5);
  }
  {
    arg7 = (meep::pml_profile_func)SWIG_MustGetPtr(s_6, SWIGTYPE_p_f_double_p_void__double, 7, 0);
  }
  {
    arg8 = (void *)SWIG_MustGetPtr(s_7, NULL, 8, 0);
  }
  {
    arg9 = (double) scm_to_double(s_8);
  }
  {
    arg10 = (double) scm_to_double(s_9);
  }
  (arg1)->use_pml(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_add_susceptibility (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-structure-chunk-add-susceptibility"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::material_function *arg2 = 0 ;
  meep::field_type arg3 ;
  meep::susceptibility *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (meep::field_type) scm_to_int(s_2); 
  }
  {
    arg4 = (meep::susceptibility *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__susceptibility, 4, 0);
  }
  (arg1)->add_susceptibility(*arg2,arg3,(meep::susceptibility const &)*arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_mix_with (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-structure-chunk-mix-with"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::structure_chunk *arg2 = (meep::structure_chunk *) 0 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::structure_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__structure_chunk, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  (arg1)->mix_with((meep::structure_chunk const *)arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_n_proc (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-n-proc"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (int)((meep::structure_chunk const *)arg1)->n_proc();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_is_mine (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-is-mine"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (int)((meep::structure_chunk const *)arg1)->is_mine();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_remove_susceptibilities (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-remove-susceptibilities"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  (arg1)->remove_susceptibilities();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_get_chi1inv_at_pt__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-chunk-get-chi1inv-at-pt"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  int arg4 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = ((meep::structure_chunk const *)arg1)->get_chi1inv_at_pt(arg2,arg3,arg4,arg5);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_get_chi1inv_at_pt__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-chunk-get-chi1inv-at-pt"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  int arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  result = ((meep::structure_chunk const *)arg1)->get_chi1inv_at_pt(arg2,arg3,arg4);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_get_chi1inv_at_pt(SCM rest)
{
#define FUNC_NAME "meep-structure-chunk-get-chi1inv-at-pt"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-structure-chunk-get-chi1inv-at-pt");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_structure_chunk_get_chi1inv_at_pt__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_structure_chunk_get_chi1inv_at_pt__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-chunk-get-chi1inv-at-pt", "No matching method for generic function `meep_structure_chunk_get_chi1inv_at_pt'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_get_chi1inv__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-chunk-get-chi1inv"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::ivec *arg4 = 0 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::ivec *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__ivec, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = ((meep::structure_chunk const *)arg1)->get_chi1inv(arg2,arg3,(meep::ivec const &)*arg4,arg5);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_get_chi1inv__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-chunk-get-chi1inv"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::ivec *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::ivec *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__ivec, 4, 0);
  }
  result = ((meep::structure_chunk const *)arg1)->get_chi1inv(arg2,arg3,(meep::ivec const &)*arg4);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_get_chi1inv(SCM rest)
{
#define FUNC_NAME "meep-structure-chunk-get-chi1inv"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-structure-chunk-get-chi1inv");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_structure_chunk_get_chi1inv__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_structure_chunk_get_chi1inv__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-chunk-get-chi1inv", "No matching method for generic function `meep_structure_chunk_get_chi1inv'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_get_inveps__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-chunk-get-inveps"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::ivec *arg4 = 0 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::ivec *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__ivec, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = ((meep::structure_chunk const *)arg1)->get_inveps(arg2,arg3,(meep::ivec const &)*arg4,arg5);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_get_inveps__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-chunk-get-inveps"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::ivec *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::ivec *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__ivec, 4, 0);
  }
  result = ((meep::structure_chunk const *)arg1)->get_inveps(arg2,arg3,(meep::ivec const &)*arg4);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_get_inveps(SCM rest)
{
#define FUNC_NAME "meep-structure-chunk-get-inveps"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-structure-chunk-get-inveps");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_structure_chunk_get_inveps__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_structure_chunk_get_inveps__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-chunk-get-inveps", "No matching method for generic function `meep_structure_chunk_get_inveps'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunk_max_eps (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunk-max-eps"
  meep::structure_chunk *arg1 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::structure_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure_chunk, 1, 0);
  }
  result = (double)((meep::structure_chunk const *)arg1)->max_eps();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_boundary_region_NOTHING_SPECIAL(SCM s_0)
{
#define FUNC_NAME "meep-boundary-region-NOTHING-SPECIAL"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_boundary_region_NOTHING_SPECIAL);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_boundary_region_PML(SCM s_0)
{
#define FUNC_NAME "meep-boundary-region-PML"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_boundary_region_PML);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_boundary_region__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-boundary-region"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region *result = 0 ;
  
  result = (meep::boundary_region *)new meep::boundary_region();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_boundary_region__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-boundary-region"
  meep::boundary_region::boundary_region_kind arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  meep::pml_profile_func arg5 = (meep::pml_profile_func) 0 ;
  void *arg6 = (void *) 0 ;
  double arg7 ;
  double arg8 ;
  meep::direction arg9 ;
  meep::boundary_side arg10 ;
  meep::boundary_region *arg11 = (meep::boundary_region *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region *result = 0 ;
  
  {
    arg1 = (meep::boundary_region::boundary_region_kind) scm_to_int(argv[0]); 
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (meep::pml_profile_func)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_f_double_p_void__double, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(argv[5], NULL, 6, 0);
  }
  {
    arg7 = (double) scm_to_double(argv[6]);
  }
  {
    arg8 = (double) scm_to_double(argv[7]);
  }
  {
    arg9 = (meep::direction) scm_to_int(argv[8]); 
  }
  {
    arg10 = (meep::boundary_side) scm_to_int(argv[9]); 
  }
  {
    arg11 = (meep::boundary_region *)SWIG_MustGetPtr(argv[10], SWIGTYPE_p_meep__boundary_region, 11, 0);
  }
  result = (meep::boundary_region *)new meep::boundary_region(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_boundary_region__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-boundary-region"
  meep::boundary_region::boundary_region_kind arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  meep::pml_profile_func arg5 = (meep::pml_profile_func) 0 ;
  void *arg6 = (void *) 0 ;
  double arg7 ;
  double arg8 ;
  meep::direction arg9 ;
  meep::boundary_side arg10 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region *result = 0 ;
  
  {
    arg1 = (meep::boundary_region::boundary_region_kind) scm_to_int(argv[0]); 
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (meep::pml_profile_func)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_f_double_p_void__double, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(argv[5], NULL, 6, 0);
  }
  {
    arg7 = (double) scm_to_double(argv[6]);
  }
  {
    arg8 = (double) scm_to_double(argv[7]);
  }
  {
    arg9 = (meep::direction) scm_to_int(argv[8]); 
  }
  {
    arg10 = (meep::boundary_side) scm_to_int(argv[9]); 
  }
  result = (meep::boundary_region *)new meep::boundary_region(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_boundary_region__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-boundary-region"
  meep::boundary_region *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region *result = 0 ;
  
  {
    arg1 = (meep::boundary_region *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__boundary_region, 1, 0);
  }
  result = (meep::boundary_region *)new meep::boundary_region((meep::boundary_region const &)*arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_boundary_region(SCM rest)
{
#define FUNC_NAME "new-meep-boundary-region"
  SCM argv[11];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 11, "new-meep-boundary-region");
  if (argc == 0) {
    return _wrap_new_meep_boundary_region__SWIG_0(argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_boundary_region__SWIG_3(argc,argv);
    }
  }
  if (argc == 10) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_f_double_p_void__double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_real_p(argv[7])) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_integer_p(argv[8])) && scm_is_true(scm_exact_p(argv[8]))? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = scm_is_true(scm_integer_p(argv[9])) && scm_is_true(scm_exact_p(argv[9]))? 1 : 0;
                      }
                      if (_v) {
                        return _wrap_new_meep_boundary_region__SWIG_2(argc,argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_f_double_p_void__double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_real_p(argv[7])) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_integer_p(argv[8])) && scm_is_true(scm_exact_p(argv[8]))? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = scm_is_true(scm_integer_p(argv[9])) && scm_is_true(scm_exact_p(argv[9]))? 1 : 0;
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, SWIGTYPE_p_meep__boundary_region, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_meep_boundary_region__SWIG_1(argc,argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-boundary-region", "No matching method for generic function `new_meep_boundary_region'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_boundary_region (SCM s_0)
{
#define FUNC_NAME "delete-meep-boundary-region"
  meep::boundary_region *arg1 = (meep::boundary_region *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::boundary_region *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__boundary_region, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_boundary_region_meep_boundary_region_add (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-boundary-region-meep-boundary-region-add"
  meep::boundary_region *arg1 = (meep::boundary_region *) 0 ;
  meep::boundary_region *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region result;
  
  {
    arg1 = (meep::boundary_region *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__boundary_region, 1, 0);
  }
  {
    arg2 = (meep::boundary_region *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__boundary_region, 2, 0);
  }
  result = ((meep::boundary_region const *)arg1)->operator +((meep::boundary_region const &)*arg2);
  {
    meep::boundary_region * resultptr;
    resultptr = new meep::boundary_region((const meep::boundary_region &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_boundary_region_meep_boundary_region_mul (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-boundary-region-meep-boundary-region-mul"
  meep::boundary_region *arg1 = (meep::boundary_region *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region result;
  
  {
    arg1 = (meep::boundary_region *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__boundary_region, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  result = ((meep::boundary_region const *)arg1)->operator *(arg2);
  {
    meep::boundary_region * resultptr;
    resultptr = new meep::boundary_region((const meep::boundary_region &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_boundary_region_apply__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-boundary-region-apply"
  meep::boundary_region *arg1 = (meep::boundary_region *) 0 ;
  meep::structure *arg2 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::boundary_region *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__boundary_region, 1, 0);
  }
  {
    arg2 = (meep::structure *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__structure, 2, 0);
  }
  ((meep::boundary_region const *)arg1)->apply(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_boundary_region_apply__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-boundary-region-apply"
  meep::boundary_region *arg1 = (meep::boundary_region *) 0 ;
  meep::structure *arg2 = (meep::structure *) 0 ;
  meep::structure_chunk *arg3 = (meep::structure_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::boundary_region *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__boundary_region, 1, 0);
  }
  {
    arg2 = (meep::structure *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__structure, 2, 0);
  }
  {
    arg3 = (meep::structure_chunk *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__structure_chunk, 3, 0);
  }
  ((meep::boundary_region const *)arg1)->apply((meep::structure const *)arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_boundary_region_apply(SCM rest)
{
#define FUNC_NAME "meep-boundary-region-apply"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-boundary-region-apply");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__boundary_region, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__structure, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_boundary_region_apply__SWIG_0(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__boundary_region, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__structure, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__structure_chunk, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_boundary_region_apply__SWIG_1(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-boundary-region-apply", "No matching method for generic function `meep_boundary_region_apply'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_boundary_region_check_ok (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-boundary-region-check-ok"
  meep::boundary_region *arg1 = (meep::boundary_region *) 0 ;
  meep::grid_volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::boundary_region *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__boundary_region, 1, 0);
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  result = (bool)((meep::boundary_region const *)arg1)->check_ok((meep::grid_volume const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_pml__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-pml"
  double arg1 ;
  meep::direction arg2 ;
  meep::boundary_side arg3 ;
  double arg4 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::boundary_side) scm_to_int(argv[2]); 
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = meep::pml(arg1,arg2,arg3,arg4,arg5);
  {
    meep::boundary_region * resultptr;
    resultptr = new meep::boundary_region((const meep::boundary_region &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_pml__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-pml"
  double arg1 ;
  meep::direction arg2 ;
  meep::boundary_side arg3 ;
  double arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::boundary_side) scm_to_int(argv[2]); 
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  result = meep::pml(arg1,arg2,arg3,arg4);
  {
    meep::boundary_region * resultptr;
    resultptr = new meep::boundary_region((const meep::boundary_region &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_pml__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-pml"
  double arg1 ;
  meep::direction arg2 ;
  meep::boundary_side arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::boundary_side) scm_to_int(argv[2]); 
  }
  result = meep::pml(arg1,arg2,arg3);
  {
    meep::boundary_region * resultptr;
    resultptr = new meep::boundary_region((const meep::boundary_region &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_pml__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-pml"
  double arg1 ;
  meep::direction arg2 ;
  double arg3 ;
  double arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  result = meep::pml(arg1,arg2,arg3,arg4);
  {
    meep::boundary_region * resultptr;
    resultptr = new meep::boundary_region((const meep::boundary_region &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_pml__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-pml"
  double arg1 ;
  meep::direction arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  result = meep::pml(arg1,arg2,arg3);
  {
    meep::boundary_region * resultptr;
    resultptr = new meep::boundary_region((const meep::boundary_region &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_pml__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-pml"
  double arg1 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  result = meep::pml(arg1,arg2);
  {
    meep::boundary_region * resultptr;
    resultptr = new meep::boundary_region((const meep::boundary_region &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_pml__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-pml"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  result = meep::pml(arg1,arg2,arg3);
  {
    meep::boundary_region * resultptr;
    resultptr = new meep::boundary_region((const meep::boundary_region &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_pml__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-pml"
  double arg1 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  result = meep::pml(arg1,arg2);
  {
    meep::boundary_region * resultptr;
    resultptr = new meep::boundary_region((const meep::boundary_region &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_pml__SWIG_8 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-pml"
  double arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_region result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  result = meep::pml(arg1);
  {
    meep::boundary_region * resultptr;
    resultptr = new meep::boundary_region((const meep::boundary_region &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__boundary_region, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_pml(SCM rest)
{
#define FUNC_NAME "meep-pml"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-pml");
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_pml__SWIG_8(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_pml__SWIG_5(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_pml__SWIG_7(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_pml__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_pml__SWIG_4(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_pml__SWIG_6(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_pml__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_pml__SWIG_3(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_pml__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-pml", "No matching method for generic function `meep_pml'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_in_or_out_Incoming(SCM s_0)
{
#define FUNC_NAME "meep-in-or-out-Incoming"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_in_or_out_Incoming);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_in_or_out_Outgoing(SCM s_0)
{
#define FUNC_NAME "meep-in-or-out-Outgoing"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_in_or_out_Outgoing);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_connect_phase_CONNECT_PHASE(SCM s_0)
{
#define FUNC_NAME "meep-connect-phase-CONNECT-PHASE"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_connect_phase_CONNECT_PHASE);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_connect_phase_CONNECT_NEGATE(SCM s_0)
{
#define FUNC_NAME "meep-connect-phase-CONNECT-NEGATE"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_connect_phase_CONNECT_NEGATE);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_connect_phase_CONNECT_COPY(SCM s_0)
{
#define FUNC_NAME "meep-connect-phase-CONNECT-COPY"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_connect_phase_CONNECT_COPY);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_NUM_CONNECT_PHASE_TYPES(SCM s_0)
{
#define FUNC_NAME "NUM-CONNECT-PHASE-TYPES"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(meep::NUM_CONNECT_PHASE_TYPES);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunks_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-chunks-set"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::structure_chunk **arg2 = (meep::structure_chunk **) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::structure_chunk **)SWIG_MustGetPtr(s_1, SWIGTYPE_p_p_meep__structure_chunk, 2, 0);
  }
  if (arg1) (arg1)->chunks = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_chunks_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-chunks-get"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure_chunk **result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (meep::structure_chunk **) ((arg1)->chunks);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_p_meep__structure_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_num_chunks_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-num-chunks-set"
  meep::structure *arg1 = (meep::structure *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  if (arg1) (arg1)->num_chunks = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_num_chunks_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-num-chunks-get"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (int) ((arg1)->num_chunks);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_shared_chunks_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-shared-chunks-set"
  meep::structure *arg1 = (meep::structure *) 0 ;
  bool arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (bool) scm_is_true(s_1);
  }
  if (arg1) (arg1)->shared_chunks = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_shared_chunks_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-shared-chunks-get"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (bool) ((arg1)->shared_chunks);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_gv_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-gv-set"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::grid_volume *arg2 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  if (arg1) (arg1)->gv = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_gv_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-gv-get"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (meep::grid_volume *)& ((arg1)->gv);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__grid_volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_user_volume_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-user-volume-set"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::grid_volume *arg2 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  if (arg1) (arg1)->user_volume = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_user_volume_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-user-volume-get"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (meep::grid_volume *)& ((arg1)->user_volume);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__grid_volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_a_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-a-set"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->a = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_a_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-a-get"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (double) ((arg1)->a);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_Courant_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-Courant-set"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->Courant = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_Courant_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-Courant-get"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (double) ((arg1)->Courant);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_dt_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-dt-set"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->dt = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_dt_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-dt-get"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (double) ((arg1)->dt);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_v_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-v-set"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::volume *arg2 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  if (arg1) (arg1)->v = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_v_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-v-get"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (meep::volume *)& ((arg1)->v);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_S_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-S-set"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::symmetry *arg2 = (meep::symmetry *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::symmetry *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__symmetry, 2, 0);
  }
  if (arg1) (arg1)->S = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_S_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-S-get"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::symmetry *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (meep::symmetry *)& ((arg1)->S);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__symmetry, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_outdir_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-outdir-set"
  meep::structure *arg1 = (meep::structure *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  {
    if (arg2) {
      arg1->outdir = (char const *) (new char[strlen((const char *)arg2)+1]);
      strcpy((char *)arg1->outdir, (const char *)arg2);
    } else {
      arg1->outdir = 0;
    }
  }
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_outdir_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-outdir-get"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (char *) ((arg1)->outdir);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_effort_volumes_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-effort-volumes-set"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::grid_volume *arg2 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  if (arg1) (arg1)->effort_volumes = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_effort_volumes_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-effort-volumes-get"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (meep::grid_volume *) ((arg1)->effort_volumes);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__grid_volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_effort_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-effort-set"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double *arg2 = (double *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_double, 2, 0);
  }
  if (arg1) (arg1)->effort = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_effort_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-effort-get"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (double *) ((arg1)->effort);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_num_effort_volumes_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-num-effort-volumes-set"
  meep::structure *arg1 = (meep::structure *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  if (arg1) (arg1)->num_effort_volumes = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_num_effort_volumes_get (SCM s_0)
{
#define FUNC_NAME "meep-structure-num-effort-volumes-get"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (int) ((arg1)->num_effort_volumes);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_structure (SCM s_0)
{
#define FUNC_NAME "delete-meep-structure"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  meep::material_function *arg2 = 0 ;
  meep::boundary_region *arg3 = 0 ;
  meep::symmetry *arg4 = 0 ;
  int arg5 ;
  double arg6 ;
  bool arg7 ;
  double arg8 ;
  int arg9 ;
  meep::binary_partition *arg10 = (meep::binary_partition *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    arg8 = (double) scm_to_double(argv[7]);
  }
  {
    arg9 = (int) scm_to_int(argv[8]);
  }
  {
    arg10 = (meep::binary_partition *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_meep__binary_partition, 10, 0);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,*arg2,(meep::boundary_region const &)*arg3,(meep::symmetry const &)*arg4,arg5,arg6,arg7,arg8,arg9,(meep::binary_partition const *)arg10);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  meep::material_function *arg2 = 0 ;
  meep::boundary_region *arg3 = 0 ;
  meep::symmetry *arg4 = 0 ;
  int arg5 ;
  double arg6 ;
  bool arg7 ;
  double arg8 ;
  int arg9 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    arg8 = (double) scm_to_double(argv[7]);
  }
  {
    arg9 = (int) scm_to_int(argv[8]);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,*arg2,(meep::boundary_region const &)*arg3,(meep::symmetry const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  meep::material_function *arg2 = 0 ;
  meep::boundary_region *arg3 = 0 ;
  meep::symmetry *arg4 = 0 ;
  int arg5 ;
  double arg6 ;
  bool arg7 ;
  double arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    arg8 = (double) scm_to_double(argv[7]);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,*arg2,(meep::boundary_region const &)*arg3,(meep::symmetry const &)*arg4,arg5,arg6,arg7,arg8);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  meep::material_function *arg2 = 0 ;
  meep::boundary_region *arg3 = 0 ;
  meep::symmetry *arg4 = 0 ;
  int arg5 ;
  double arg6 ;
  bool arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,*arg2,(meep::boundary_region const &)*arg3,(meep::symmetry const &)*arg4,arg5,arg6,arg7);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  meep::material_function *arg2 = 0 ;
  meep::boundary_region *arg3 = 0 ;
  meep::symmetry *arg4 = 0 ;
  int arg5 ;
  double arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,*arg2,(meep::boundary_region const &)*arg3,(meep::symmetry const &)*arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  meep::material_function *arg2 = 0 ;
  meep::boundary_region *arg3 = 0 ;
  meep::symmetry *arg4 = 0 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,*arg2,(meep::boundary_region const &)*arg3,(meep::symmetry const &)*arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  meep::material_function *arg2 = 0 ;
  meep::boundary_region *arg3 = 0 ;
  meep::symmetry *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,*arg2,(meep::boundary_region const &)*arg3,(meep::symmetry const &)*arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  meep::material_function *arg2 = 0 ;
  meep::boundary_region *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,*arg2,(meep::boundary_region const &)*arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_8 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  meep::material_function *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,*arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_9 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  meep::boundary_region *arg3 = 0 ;
  meep::symmetry *arg4 = 0 ;
  int arg5 ;
  double arg6 ;
  bool arg7 ;
  double arg8 ;
  int arg9 ;
  meep::binary_partition *arg10 = (meep::binary_partition *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    arg8 = (double) scm_to_double(argv[7]);
  }
  {
    arg9 = (int) scm_to_int(argv[8]);
  }
  {
    arg10 = (meep::binary_partition *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_meep__binary_partition, 10, 0);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,arg2,(meep::boundary_region const &)*arg3,(meep::symmetry const &)*arg4,arg5,arg6,arg7,arg8,arg9,(meep::binary_partition const *)arg10);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_10 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  meep::boundary_region *arg3 = 0 ;
  meep::symmetry *arg4 = 0 ;
  int arg5 ;
  double arg6 ;
  bool arg7 ;
  double arg8 ;
  int arg9 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    arg8 = (double) scm_to_double(argv[7]);
  }
  {
    arg9 = (int) scm_to_int(argv[8]);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,arg2,(meep::boundary_region const &)*arg3,(meep::symmetry const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_11 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  meep::boundary_region *arg3 = 0 ;
  meep::symmetry *arg4 = 0 ;
  int arg5 ;
  double arg6 ;
  bool arg7 ;
  double arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    arg8 = (double) scm_to_double(argv[7]);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,arg2,(meep::boundary_region const &)*arg3,(meep::symmetry const &)*arg4,arg5,arg6,arg7,arg8);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_12 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  meep::boundary_region *arg3 = 0 ;
  meep::symmetry *arg4 = 0 ;
  int arg5 ;
  double arg6 ;
  bool arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,arg2,(meep::boundary_region const &)*arg3,(meep::symmetry const &)*arg4,arg5,arg6,arg7);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_13 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  meep::boundary_region *arg3 = 0 ;
  meep::symmetry *arg4 = 0 ;
  int arg5 ;
  double arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,arg2,(meep::boundary_region const &)*arg3,(meep::symmetry const &)*arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_14 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  meep::boundary_region *arg3 = 0 ;
  meep::symmetry *arg4 = 0 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,arg2,(meep::boundary_region const &)*arg3,(meep::symmetry const &)*arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_15 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  meep::boundary_region *arg3 = 0 ;
  meep::symmetry *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,arg2,(meep::boundary_region const &)*arg3,(meep::symmetry const &)*arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_16 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  meep::boundary_region *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,arg2,(meep::boundary_region const &)*arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_17 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::grid_volume *arg1 = 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::grid_volume *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__grid_volume, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  result = (meep::structure *)new meep::structure((meep::grid_volume const &)*arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure__SWIG_18 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-structure"
  meep::structure *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (meep::structure *)new meep::structure((meep::structure const &)*arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_structure(SCM rest)
{
#define FUNC_NAME "new-meep-structure"
  SCM argv[10];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 10, "new-meep-structure");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_structure__SWIG_18(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_meep_structure__SWIG_17(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_meep_structure__SWIG_8(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_meep_structure__SWIG_7(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_meep_structure__SWIG_16(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_meep_structure__SWIG_15(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_meep_structure__SWIG_6(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_new_meep_structure__SWIG_5(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_new_meep_structure__SWIG_14(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                return _wrap_new_meep_structure__SWIG_13(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                return _wrap_new_meep_structure__SWIG_4(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_new_meep_structure__SWIG_3(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_new_meep_structure__SWIG_12(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_real_p(argv[7])) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_new_meep_structure__SWIG_11(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_real_p(argv[7])) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_new_meep_structure__SWIG_2(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_real_p(argv[7])) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_integer_p(argv[8])) && scm_is_true(scm_exact_p(argv[8]))? 1 : 0;
                    }
                    if (_v) {
                      return _wrap_new_meep_structure__SWIG_1(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_real_p(argv[7])) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_integer_p(argv[8])) && scm_is_true(scm_exact_p(argv[8]))? 1 : 0;
                    }
                    if (_v) {
                      return _wrap_new_meep_structure__SWIG_10(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_real_p(argv[7])) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_integer_p(argv[8])) && scm_is_true(scm_exact_p(argv[8]))? 1 : 0;
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_meep__binary_partition, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_meep_structure__SWIG_9(argc,argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__grid_volume, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__symmetry, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_real_p(argv[7])) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_integer_p(argv[8])) && scm_is_true(scm_exact_p(argv[8]))? 1 : 0;
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_meep__binary_partition, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_meep_structure__SWIG_0(argc,argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-structure", "No matching method for generic function `new_meep_structure'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_materials__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-materials"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  bool arg3 ;
  double arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  (arg1)->set_materials(*arg2,arg3,arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_materials__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-materials"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  bool arg3 ;
  double arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  (arg1)->set_materials(*arg2,arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_materials__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-materials"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  bool arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  (arg1)->set_materials(*arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_materials__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-materials"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  (arg1)->set_materials(*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_materials(SCM rest)
{
#define FUNC_NAME "meep-structure-set-materials"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-structure-set-materials");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_structure_set_materials__SWIG_3(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_structure_set_materials__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_structure_set_materials__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_structure_set_materials__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-set-materials", "No matching method for generic function `meep_structure_set_materials'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_chi1inv__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-chi1inv"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::material_function *arg3 = 0 ;
  bool arg4 ;
  double arg5 ;
  int arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::material_function *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__material_function, 3, 0);
  }
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  (arg1)->set_chi1inv(arg2,*arg3,arg4,arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_chi1inv__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-chi1inv"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::material_function *arg3 = 0 ;
  bool arg4 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::material_function *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__material_function, 3, 0);
  }
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  (arg1)->set_chi1inv(arg2,*arg3,arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_chi1inv__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-chi1inv"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::material_function *arg3 = 0 ;
  bool arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::material_function *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__material_function, 3, 0);
  }
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  (arg1)->set_chi1inv(arg2,*arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_chi1inv__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-chi1inv"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::material_function *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::material_function *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__material_function, 3, 0);
  }
  (arg1)->set_chi1inv(arg2,*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_chi1inv(SCM rest)
{
#define FUNC_NAME "meep-structure-set-chi1inv"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "meep-structure-set-chi1inv");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_structure_set_chi1inv__SWIG_3(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_structure_set_chi1inv__SWIG_2(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_structure_set_chi1inv__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_structure_set_chi1inv__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-set-chi1inv", "No matching method for generic function `meep_structure_set_chi1inv'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_has_chi (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-structure-has-chi"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::direction) scm_to_int(s_2); 
  }
  result = (bool)((meep::structure const *)arg1)->has_chi(arg2,arg3);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_epsilon__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-epsilon"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  bool arg3 ;
  double arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  (arg1)->set_epsilon(*arg2,arg3,arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_epsilon__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-epsilon"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  bool arg3 ;
  double arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  (arg1)->set_epsilon(*arg2,arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_epsilon__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-epsilon"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  bool arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  (arg1)->set_epsilon(*arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_epsilon__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-epsilon"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  (arg1)->set_epsilon(*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_epsilon__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-epsilon"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  bool arg3 ;
  double arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  (arg1)->set_epsilon(arg2,arg3,arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_epsilon__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-epsilon"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  bool arg3 ;
  double arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  (arg1)->set_epsilon(arg2,arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_epsilon__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-epsilon"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  bool arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  (arg1)->set_epsilon(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_epsilon__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-epsilon"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  (arg1)->set_epsilon(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_epsilon(SCM rest)
{
#define FUNC_NAME "meep-structure-set-epsilon"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-structure-set-epsilon");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_structure_set_epsilon__SWIG_3(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_structure_set_epsilon__SWIG_7(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_structure_set_epsilon__SWIG_6(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_structure_set_epsilon__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_structure_set_epsilon__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_structure_set_epsilon__SWIG_5(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_structure_set_epsilon__SWIG_4(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_structure_set_epsilon__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-set-epsilon", "No matching method for generic function `meep_structure_set_epsilon'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_mu__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-mu"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  bool arg3 ;
  double arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  (arg1)->set_mu(*arg2,arg3,arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_mu__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-mu"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  bool arg3 ;
  double arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  (arg1)->set_mu(*arg2,arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_mu__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-mu"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  bool arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  (arg1)->set_mu(*arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_mu__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-mu"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  (arg1)->set_mu(*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_mu__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-mu"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  bool arg3 ;
  double arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  (arg1)->set_mu(arg2,arg3,arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_mu__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-mu"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  bool arg3 ;
  double arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  (arg1)->set_mu(arg2,arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_mu__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-mu"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  bool arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  (arg1)->set_mu(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_mu__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-mu"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  (arg1)->set_mu(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_mu(SCM rest)
{
#define FUNC_NAME "meep-structure-set-mu"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-structure-set-mu");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_structure_set_mu__SWIG_3(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_structure_set_mu__SWIG_7(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_structure_set_mu__SWIG_6(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_structure_set_mu__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_structure_set_mu__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_structure_set_mu__SWIG_5(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_structure_set_mu__SWIG_4(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_structure_set_mu__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-set-mu", "No matching method for generic function `meep_structure_set_mu'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_conductivity__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-conductivity"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::material_function *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::material_function *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__material_function, 3, 0);
  }
  (arg1)->set_conductivity(arg2,*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_conductivity__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-conductivity"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  double (*arg3)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[2], SWIGTYPE_p_f_r_q_const__meep__vec__double, 3, 0);
  }
  (arg1)->set_conductivity(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_conductivity(SCM rest)
{
#define FUNC_NAME "meep-structure-set-conductivity"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-structure-set-conductivity");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_structure_set_conductivity__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_structure_set_conductivity__SWIG_1(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-set-conductivity", "No matching method for generic function `meep_structure_set_conductivity'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_chi3__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-chi3"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::material_function *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::material_function *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__material_function, 3, 0);
  }
  (arg1)->set_chi3(arg2,*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_chi3__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-chi3"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  (arg1)->set_chi3(*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_chi3__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-chi3"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  (arg1)->set_chi3(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_chi3(SCM rest)
{
#define FUNC_NAME "meep-structure-set-chi3"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-structure-set-chi3");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_structure_set_chi3__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_structure_set_chi3__SWIG_2(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_structure_set_chi3__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-set-chi3", "No matching method for generic function `meep_structure_set_chi3'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_chi2__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-chi2"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::material_function *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::material_function *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__material_function, 3, 0);
  }
  (arg1)->set_chi2(arg2,*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_chi2__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-chi2"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  (arg1)->set_chi2(*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_chi2__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-set-chi2"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  (arg1)->set_chi2(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_chi2(SCM rest)
{
#define FUNC_NAME "meep-structure-set-chi2"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-structure-set-chi2");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_structure_set_chi2__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_structure_set_chi2__SWIG_2(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_structure_set_chi2__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-set-chi2", "No matching method for generic function `meep_structure_set_chi2'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_add_susceptibility__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-add-susceptibility"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  meep::field_type arg3 ;
  meep::susceptibility *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (meep::field_type) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::susceptibility *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__susceptibility, 4, 0);
  }
  (arg1)->add_susceptibility(arg2,arg3,(meep::susceptibility const &)*arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_add_susceptibility__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-add-susceptibility"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::material_function *arg2 = 0 ;
  meep::field_type arg3 ;
  meep::susceptibility *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::material_function *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__material_function, 2, 0);
  }
  {
    arg3 = (meep::field_type) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::susceptibility *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__susceptibility, 4, 0);
  }
  (arg1)->add_susceptibility(*arg2,arg3,(meep::susceptibility const &)*arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_add_susceptibility(SCM rest)
{
#define FUNC_NAME "meep-structure-add-susceptibility"
  SCM argv[4];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 4, "meep-structure-add-susceptibility");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__meep__vec__double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__susceptibility, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_structure_add_susceptibility__SWIG_0(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__material_function, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__susceptibility, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_structure_add_susceptibility__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-add-susceptibility", "No matching method for generic function `meep_structure_add_susceptibility'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_remove_susceptibilities (SCM s_0)
{
#define FUNC_NAME "meep-structure-remove-susceptibilities"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  (arg1)->remove_susceptibilities();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_set_output_directory (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-set-output-directory"
  meep::structure *arg1 = (meep::structure *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  (arg1)->set_output_directory((char const *)arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_mix_with (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-structure-mix-with"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::structure *arg2 = (meep::structure *) 0 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::structure *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__structure, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  (arg1)->mix_with((meep::structure const *)arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_equal_layout (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-equal-layout"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::structure *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::structure *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__structure, 2, 0);
  }
  result = (bool)((meep::structure const *)arg1)->equal_layout((meep::structure const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_print_layout (SCM s_0)
{
#define FUNC_NAME "meep-structure-print-layout"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  ((meep::structure const *)arg1)->print_layout();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_chunk_volumes (SCM s_0)
{
#define FUNC_NAME "meep-structure-get-chunk-volumes"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< std::vector< meep::grid_volume > > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = ((meep::structure const *)arg1)->get_chunk_volumes();
  {
    std::vector< meep::grid_volume > * resultptr;
    resultptr = new std::vector< meep::grid_volume >((const std::vector< meep::grid_volume > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_meep__grid_volume_t, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_chunk_owners (SCM s_0)
{
#define FUNC_NAME "meep-structure-get-chunk-owners"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< int > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = ((meep::structure const *)arg1)->get_chunk_owners();
  {
    std::vector< int > * resultptr;
    resultptr = new std::vector< int >((const std::vector< int > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_int_t, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_dump__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-dump"
  meep::structure *arg1 = (meep::structure *) 0 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  (arg1)->dump((char const *)arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_dump__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-dump"
  meep::structure *arg1 = (meep::structure *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  (arg1)->dump((char const *)arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_dump(SCM rest)
{
#define FUNC_NAME "meep-structure-dump"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-structure-dump");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_structure_dump__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_structure_dump__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-dump", "No matching method for generic function `meep_structure_dump'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_load__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-load"
  meep::structure *arg1 = (meep::structure *) 0 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  (arg1)->load((char const *)arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_load__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-load"
  meep::structure *arg1 = (meep::structure *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  (arg1)->load((char const *)arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_load(SCM rest)
{
#define FUNC_NAME "meep-structure-load"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-structure-load");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_structure_load__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_structure_load__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-load", "No matching method for generic function `meep_structure_load'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_dump_chunk_layout (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-structure-dump-chunk-layout"
  meep::structure *arg1 = (meep::structure *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  (arg1)->dump_chunk_layout((char const *)arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_load_chunk_layout__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-load-chunk-layout"
  meep::structure *arg1 = (meep::structure *) 0 ;
  char *arg2 = (char *) 0 ;
  meep::boundary_region *arg3 = 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (meep::boundary_region *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__boundary_region, 3, 0);
  }
  (arg1)->load_chunk_layout((char const *)arg2,*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_load_chunk_layout__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-load-chunk-layout"
  meep::structure *arg1 = (meep::structure *) 0 ;
  std::vector< meep::grid_volume > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  meep::boundary_region *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (std::vector< meep::grid_volume > *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_std__vectorT_meep__grid_volume_t, 2, 0);
  }
  {
    arg3 = (std::vector< int > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_int_t, 3, 0);
  }
  {
    arg4 = (meep::boundary_region *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__boundary_region, 4, 0);
  }
  (arg1)->load_chunk_layout((std::vector< meep::grid_volume > const &)*arg2,(std::vector< int > const &)*arg3,*arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_load_chunk_layout(SCM rest)
{
#define FUNC_NAME "meep-structure-load-chunk-layout"
  SCM argv[4];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 4, "meep-structure-load-chunk-layout");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_structure_load_chunk_layout__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_std__vectorT_meep__grid_volume_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_int_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__boundary_region, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_structure_load_chunk_layout__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-load-chunk-layout", "No matching method for generic function `meep_structure_load_chunk_layout'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_chi1inv__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-get-chi1inv"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::ivec *arg4 = 0 ;
  double arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::ivec *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__ivec, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = ((meep::structure const *)arg1)->get_chi1inv(arg2,arg3,(meep::ivec const &)*arg4,arg5,arg6);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_chi1inv__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-get-chi1inv"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::ivec *arg4 = 0 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::ivec *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__ivec, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = ((meep::structure const *)arg1)->get_chi1inv(arg2,arg3,(meep::ivec const &)*arg4,arg5);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_chi1inv__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-get-chi1inv"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::ivec *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::ivec *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__ivec, 4, 0);
  }
  result = ((meep::structure const *)arg1)->get_chi1inv(arg2,arg3,(meep::ivec const &)*arg4);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_chi1inv__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-get-chi1inv"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::vec *arg4 = 0 ;
  double arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  
  meep::vec vec__arg4 = vector3_to_vec(ctl_convert_vector3_to_c(argv[3]));
  arg4 = &vec__arg4;
  
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = ((meep::structure const *)arg1)->get_chi1inv(arg2,arg3,(meep::vec const &)*arg4,arg5,arg6);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_chi1inv__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-get-chi1inv"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::vec *arg4 = 0 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  
  meep::vec vec__arg4 = vector3_to_vec(ctl_convert_vector3_to_c(argv[3]));
  arg4 = &vec__arg4;
  
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = ((meep::structure const *)arg1)->get_chi1inv(arg2,arg3,(meep::vec const &)*arg4,arg5);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_chi1inv__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-get-chi1inv"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::vec *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  
  meep::vec vec__arg4 = vector3_to_vec(ctl_convert_vector3_to_c(argv[3]));
  arg4 = &vec__arg4;
  
  result = ((meep::structure const *)arg1)->get_chi1inv(arg2,arg3,(meep::vec const &)*arg4);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_chi1inv(SCM rest)
{
#define FUNC_NAME "meep-structure-get-chi1inv"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "meep-structure-get-chi1inv");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_structure_get_chi1inv__SWIG_2(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigVector3_Check(argv[3]);
          }
          if (_v) {
            return _wrap_meep_structure_get_chi1inv__SWIG_5(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_structure_get_chi1inv__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigVector3_Check(argv[3]);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_structure_get_chi1inv__SWIG_4(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_structure_get_chi1inv__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigVector3_Check(argv[3]);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_structure_get_chi1inv__SWIG_3(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-get-chi1inv", "No matching method for generic function `meep_structure_get_chi1inv'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_inveps__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-get-inveps"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::ivec *arg4 = 0 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::ivec *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__ivec, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = ((meep::structure const *)arg1)->get_inveps(arg2,arg3,(meep::ivec const &)*arg4,arg5);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_inveps__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-get-inveps"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::ivec *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::ivec *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__ivec, 4, 0);
  }
  result = ((meep::structure const *)arg1)->get_inveps(arg2,arg3,(meep::ivec const &)*arg4);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_inveps__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-get-inveps"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::vec *arg4 = 0 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  
  meep::vec vec__arg4 = vector3_to_vec(ctl_convert_vector3_to_c(argv[3]));
  arg4 = &vec__arg4;
  
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = ((meep::structure const *)arg1)->get_inveps(arg2,arg3,(meep::vec const &)*arg4,arg5);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_inveps__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-get-inveps"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::vec *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  
  meep::vec vec__arg4 = vector3_to_vec(ctl_convert_vector3_to_c(argv[3]));
  arg4 = &vec__arg4;
  
  result = ((meep::structure const *)arg1)->get_inveps(arg2,arg3,(meep::vec const &)*arg4);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_inveps(SCM rest)
{
#define FUNC_NAME "meep-structure-get-inveps"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-structure-get-inveps");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_structure_get_inveps__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigVector3_Check(argv[3]);
          }
          if (_v) {
            return _wrap_meep_structure_get_inveps__SWIG_3(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_structure_get_inveps__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigVector3_Check(argv[3]);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_structure_get_inveps__SWIG_2(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-get-inveps", "No matching method for generic function `meep_structure_get_inveps'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_eps__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-get-eps"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::vec *arg2 = 0 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  result = ((meep::structure const *)arg1)->get_eps((meep::vec const &)*arg2,arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_eps__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-get-eps"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  result = ((meep::structure const *)arg1)->get_eps((meep::vec const &)*arg2);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_eps(SCM rest)
{
#define FUNC_NAME "meep-structure-get-eps"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-structure-get-eps");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        return _wrap_meep_structure_get_eps__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_structure_get_eps__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-get-eps", "No matching method for generic function `meep_structure_get_eps'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_mu__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-get-mu"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::vec *arg2 = 0 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  result = ((meep::structure const *)arg1)->get_mu((meep::vec const &)*arg2,arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_mu__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-get-mu"
  meep::structure *arg1 = (meep::structure *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  result = ((meep::structure const *)arg1)->get_mu((meep::vec const &)*arg2);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_mu(SCM rest)
{
#define FUNC_NAME "meep-structure-get-mu"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-structure-get-mu");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        return _wrap_meep_structure_get_mu__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_structure_get_mu__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-structure-get-mu", "No matching method for generic function `meep_structure_get_mu'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_max_eps (SCM s_0)
{
#define FUNC_NAME "meep-structure-max-eps"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (double)((meep::structure const *)arg1)->max_eps();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_estimated_cost__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-estimated-cost"
  meep::structure *arg1 = (meep::structure *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  result = (double)(arg1)->estimated_cost(arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_estimated_cost__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-structure-estimated-cost"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (double)(arg1)->estimated_cost();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_estimated_cost(SCM rest)
{
#define FUNC_NAME "meep-structure-estimated-cost"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-structure-estimated-cost");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_structure_estimated_cost__SWIG_1(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_structure_estimated_cost__SWIG_0(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-structure-estimated-cost", "No matching method for generic function `meep_structure_estimated_cost'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_structure_get_binary_partition (SCM s_0)
{
#define FUNC_NAME "meep-structure-get-binary-partition"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::binary_partition *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (meep::binary_partition *)((meep::structure const *)arg1)->get_binary_partition();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__binary_partition, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_split_by_binarytree (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-split-by-binarytree"
  meep::grid_volume arg1 ;
  std::vector< meep::grid_volume > *arg2 = 0 ;
  std::vector< int > *arg3 = 0 ;
  meep::binary_partition *arg4 = (meep::binary_partition *) 0 ;
  meep::grid_volume *argp1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    argp1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
    arg1 = *argp1;
  }
  {
    arg2 = (std::vector< meep::grid_volume > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__vectorT_meep__grid_volume_t, 2, 0);
  }
  {
    arg3 = (std::vector< int > *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_std__vectorT_int_t, 3, 0);
  }
  {
    arg4 = (meep::binary_partition *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__binary_partition, 4, 0);
  }
  meep::split_by_binarytree(arg1,*arg2,*arg3,(meep::binary_partition const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_is_integrated_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-src-time-is-integrated-set"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  bool arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  {
    arg2 = (bool) scm_is_true(s_1);
  }
  if (arg1) (arg1)->is_integrated = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_is_integrated_get (SCM s_0)
{
#define FUNC_NAME "meep-src-time-is-integrated-get"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  result = (bool) ((arg1)->is_integrated);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_id_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-src-time-id-set"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  size_t arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  {
    arg2 = (size_t) scm_to_ulong(s_1);
  }
  if (arg1) (arg1)->id = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_id_get (SCM s_0)
{
#define FUNC_NAME "meep-src-time-id-get"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  size_t result;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  result =  ((arg1)->id);
  {
    gswig_result = scm_from_ulong(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_src_time__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-src-time"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::src_time *result = 0 ;
  
  result = (meep::src_time *)new meep::src_time();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__src_time, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_src_time (SCM s_0)
{
#define FUNC_NAME "delete-meep-src-time"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_src_time__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-src-time"
  meep::src_time *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::src_time *result = 0 ;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__src_time, 1, 0);
  }
  result = (meep::src_time *)new meep::src_time((meep::src_time const &)*arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__src_time, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_src_time(SCM rest)
{
#define FUNC_NAME "new-meep-src-time"
  SCM argv[1];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 1, "new-meep-src-time");
  if (argc == 0) {
    return _wrap_new_meep_src_time__SWIG_0(argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__src_time, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_src_time__SWIG_1(argc,argv);
    }
  }
  
  scm_misc_error("new-meep-src-time", "No matching method for generic function `new_meep_src_time'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_dipole__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-src-time-dipole"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__src_time, 1, 0);
  }
  result = ((meep::src_time const *)arg1)->dipole();
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_current__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-src-time-current"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__src_time, 1, 0);
  }
  result = ((meep::src_time const *)arg1)->current();
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_update (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-src-time-update"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  double arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  (arg1)->update(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_current__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-src-time-current"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  double arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__src_time, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  result = ((meep::src_time const *)arg1)->current(arg2,arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_current(SCM rest)
{
#define FUNC_NAME "meep-src-time-current"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-src-time-current");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__src_time, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_src_time_current__SWIG_0(argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__src_time, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_src_time_current__SWIG_1(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-src-time-current", "No matching method for generic function `meep_src_time_current'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_last_time_max__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-src-time-last-time-max"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__src_time, 1, 0);
  }
  result = (double)(arg1)->last_time_max();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_last_time_max__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-src-time-last-time-max"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__src_time, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  result = (double)(arg1)->last_time_max(arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_last_time_max(SCM rest)
{
#define FUNC_NAME "meep-src-time-last-time-max"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-src-time-last-time-max");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__src_time, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_src_time_last_time_max__SWIG_0(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__src_time, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_src_time_last_time_max__SWIG_1(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-src-time-last-time-max", "No matching method for generic function `meep_src_time_last_time_max'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_add_to (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-src-time-add-to"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  meep::src_time *arg2 = (meep::src_time *) 0 ;
  meep::src_time **arg3 = (meep::src_time **) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::src_time *result = 0 ;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  {
    arg2 = (meep::src_time *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__src_time, 2, 0);
  }
  {
    arg3 = (meep::src_time **)SWIG_MustGetPtr(s_2, SWIGTYPE_p_p_meep__src_time, 3, 0);
  }
  result = (meep::src_time *)((meep::src_time const *)arg1)->add_to(arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__src_time, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_next_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-src-time-next-set"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  meep::src_time *arg2 = (meep::src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  {
    arg2 = (meep::src_time *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__src_time, 2, 0);
  }
  if (arg1) (arg1)->next = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_next_get (SCM s_0)
{
#define FUNC_NAME "meep-src-time-next-get"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::src_time *result = 0 ;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  result = (meep::src_time *) ((arg1)->next);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__src_time, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_dipole__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-src-time-dipole"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__src_time, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  result = ((meep::src_time const *)arg1)->dipole(arg2);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_dipole(SCM rest)
{
#define FUNC_NAME "meep-src-time-dipole"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-src-time-dipole");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__src_time, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_src_time_dipole__SWIG_0(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__src_time, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_src_time_dipole__SWIG_1(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-src-time-dipole", "No matching method for generic function `meep_src_time_dipole'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_last_time (SCM s_0)
{
#define FUNC_NAME "meep-src-time-last-time"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  result = (double)((meep::src_time const *)arg1)->last_time();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_clone (SCM s_0)
{
#define FUNC_NAME "meep-src-time-clone"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::src_time *result = 0 ;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  result = (meep::src_time *)((meep::src_time const *)arg1)->clone();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__src_time, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_is_equal (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-src-time-is-equal"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  meep::src_time *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  {
    arg2 = (meep::src_time *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__src_time, 2, 0);
  }
  result = (bool)((meep::src_time const *)arg1)->is_equal((meep::src_time const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_frequency (SCM s_0)
{
#define FUNC_NAME "meep-src-time-frequency"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  result = ((meep::src_time const *)arg1)->frequency();
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_get_fwidth (SCM s_0)
{
#define FUNC_NAME "meep-src-time-get-fwidth"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  result = (double)((meep::src_time const *)arg1)->get_fwidth();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_set_fwidth (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-src-time-set-fwidth"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  (arg1)->set_fwidth(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_time_set_frequency (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-src-time-set-frequency"
  meep::src_time *arg1 = (meep::src_time *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->set_frequency(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_src_times_equal (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-src-times-equal"
  meep::src_time *arg1 = 0 ;
  meep::src_time *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__src_time, 1, 0);
  }
  {
    arg2 = (meep::src_time *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__src_time, 2, 0);
  }
  result = (bool)meep::src_times_equal((meep::src_time const &)*arg1,(meep::src_time const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_gaussian_src_time__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-gaussian-src-time"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::gaussian_src_time *result = 0 ;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  result = (meep::gaussian_src_time *)new meep::gaussian_src_time(arg1,arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__gaussian_src_time, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_gaussian_src_time__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-gaussian-src-time"
  double arg1 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::gaussian_src_time *result = 0 ;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  result = (meep::gaussian_src_time *)new meep::gaussian_src_time(arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__gaussian_src_time, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_gaussian_src_time__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-gaussian-src-time"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::gaussian_src_time *result = 0 ;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  result = (meep::gaussian_src_time *)new meep::gaussian_src_time(arg1,arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__gaussian_src_time, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_gaussian_src_time(SCM rest)
{
#define FUNC_NAME "new-meep-gaussian-src-time"
  SCM argv[4];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 4, "new-meep-gaussian-src-time");
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_new_meep_gaussian_src_time__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_new_meep_gaussian_src_time__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            return _wrap_new_meep_gaussian_src_time__SWIG_2(argc,argv);
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-gaussian-src-time", "No matching method for generic function `new_meep_gaussian_src_time'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_gaussian_src_time (SCM s_0)
{
#define FUNC_NAME "delete-meep-gaussian-src-time"
  meep::gaussian_src_time *arg1 = (meep::gaussian_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::gaussian_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gaussian_src_time, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gaussian_src_time_dipole (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-gaussian-src-time-dipole"
  meep::gaussian_src_time *arg1 = (meep::gaussian_src_time *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::gaussian_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gaussian_src_time, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  result = ((meep::gaussian_src_time const *)arg1)->dipole(arg2);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gaussian_src_time_last_time (SCM s_0)
{
#define FUNC_NAME "meep-gaussian-src-time-last-time"
  meep::gaussian_src_time *arg1 = (meep::gaussian_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::gaussian_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gaussian_src_time, 1, 0);
  }
  result = (double)((meep::gaussian_src_time const *)arg1)->last_time();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gaussian_src_time_clone (SCM s_0)
{
#define FUNC_NAME "meep-gaussian-src-time-clone"
  meep::gaussian_src_time *arg1 = (meep::gaussian_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::src_time *result = 0 ;
  
  {
    arg1 = (meep::gaussian_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gaussian_src_time, 1, 0);
  }
  result = (meep::src_time *)((meep::gaussian_src_time const *)arg1)->clone();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__src_time, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gaussian_src_time_is_equal (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-gaussian-src-time-is-equal"
  meep::gaussian_src_time *arg1 = (meep::gaussian_src_time *) 0 ;
  meep::src_time *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::gaussian_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gaussian_src_time, 1, 0);
  }
  {
    arg2 = (meep::src_time *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__src_time, 2, 0);
  }
  result = (bool)((meep::gaussian_src_time const *)arg1)->is_equal((meep::src_time const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gaussian_src_time_frequency (SCM s_0)
{
#define FUNC_NAME "meep-gaussian-src-time-frequency"
  meep::gaussian_src_time *arg1 = (meep::gaussian_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::gaussian_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gaussian_src_time, 1, 0);
  }
  result = ((meep::gaussian_src_time const *)arg1)->frequency();
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gaussian_src_time_get_fwidth (SCM s_0)
{
#define FUNC_NAME "meep-gaussian-src-time-get-fwidth"
  meep::gaussian_src_time *arg1 = (meep::gaussian_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::gaussian_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gaussian_src_time, 1, 0);
  }
  result = (double)((meep::gaussian_src_time const *)arg1)->get_fwidth();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gaussian_src_time_set_fwidth (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-gaussian-src-time-set-fwidth"
  meep::gaussian_src_time *arg1 = (meep::gaussian_src_time *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::gaussian_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gaussian_src_time, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  (arg1)->set_fwidth(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gaussian_src_time_set_frequency (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-gaussian-src-time-set-frequency"
  meep::gaussian_src_time *arg1 = (meep::gaussian_src_time *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::gaussian_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gaussian_src_time, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->set_frequency(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gaussian_src_time_fourier_transform (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-gaussian-src-time-fourier-transform"
  meep::gaussian_src_time *arg1 = (meep::gaussian_src_time *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::gaussian_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gaussian_src_time, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  result = (arg1)->fourier_transform(arg2);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_continuous_src_time__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-continuous-src-time"
  std::complex< double > arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::continuous_src_time *result = 0 ;
  
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[0]);
    arg1 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = (meep::continuous_src_time *)new meep::continuous_src_time(arg1,arg2,arg3,arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__continuous_src_time, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_continuous_src_time__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-continuous-src-time"
  std::complex< double > arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::continuous_src_time *result = 0 ;
  
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[0]);
    arg1 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  result = (meep::continuous_src_time *)new meep::continuous_src_time(arg1,arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__continuous_src_time, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_continuous_src_time__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-continuous-src-time"
  std::complex< double > arg1 ;
  double arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::continuous_src_time *result = 0 ;
  
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[0]);
    arg1 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  result = (meep::continuous_src_time *)new meep::continuous_src_time(arg1,arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__continuous_src_time, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_continuous_src_time__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-continuous-src-time"
  std::complex< double > arg1 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::continuous_src_time *result = 0 ;
  
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[0]);
    arg1 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  result = (meep::continuous_src_time *)new meep::continuous_src_time(arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__continuous_src_time, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_continuous_src_time__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-continuous-src-time"
  std::complex< double > arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::continuous_src_time *result = 0 ;
  
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[0]);
    arg1 = std::complex<double>(cnum.re, cnum.im);
  }
  result = (meep::continuous_src_time *)new meep::continuous_src_time(arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__continuous_src_time, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_continuous_src_time(SCM rest)
{
#define FUNC_NAME "new-meep-continuous-src-time"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "new-meep-continuous-src-time");
  if (argc == 1) {
    int _v;
    {
      _v = SwigComplex_Check(argv[0]);
    }
    if (_v) {
      return _wrap_new_meep_continuous_src_time__SWIG_4(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = SwigComplex_Check(argv[0]);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_new_meep_continuous_src_time__SWIG_3(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = SwigComplex_Check(argv[0]);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_new_meep_continuous_src_time__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = SwigComplex_Check(argv[0]);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            return _wrap_new_meep_continuous_src_time__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = SwigComplex_Check(argv[0]);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_new_meep_continuous_src_time__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-continuous-src-time", "No matching method for generic function `new_meep_continuous_src_time'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_continuous_src_time (SCM s_0)
{
#define FUNC_NAME "delete-meep-continuous-src-time"
  meep::continuous_src_time *arg1 = (meep::continuous_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::continuous_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__continuous_src_time, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_continuous_src_time_dipole (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-continuous-src-time-dipole"
  meep::continuous_src_time *arg1 = (meep::continuous_src_time *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::continuous_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__continuous_src_time, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  result = ((meep::continuous_src_time const *)arg1)->dipole(arg2);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_continuous_src_time_last_time (SCM s_0)
{
#define FUNC_NAME "meep-continuous-src-time-last-time"
  meep::continuous_src_time *arg1 = (meep::continuous_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::continuous_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__continuous_src_time, 1, 0);
  }
  result = (double)((meep::continuous_src_time const *)arg1)->last_time();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_continuous_src_time_clone (SCM s_0)
{
#define FUNC_NAME "meep-continuous-src-time-clone"
  meep::continuous_src_time *arg1 = (meep::continuous_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::src_time *result = 0 ;
  
  {
    arg1 = (meep::continuous_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__continuous_src_time, 1, 0);
  }
  result = (meep::src_time *)((meep::continuous_src_time const *)arg1)->clone();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__src_time, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_continuous_src_time_is_equal (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-continuous-src-time-is-equal"
  meep::continuous_src_time *arg1 = (meep::continuous_src_time *) 0 ;
  meep::src_time *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::continuous_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__continuous_src_time, 1, 0);
  }
  {
    arg2 = (meep::src_time *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__src_time, 2, 0);
  }
  result = (bool)((meep::continuous_src_time const *)arg1)->is_equal((meep::src_time const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_continuous_src_time_frequency (SCM s_0)
{
#define FUNC_NAME "meep-continuous-src-time-frequency"
  meep::continuous_src_time *arg1 = (meep::continuous_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::continuous_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__continuous_src_time, 1, 0);
  }
  result = ((meep::continuous_src_time const *)arg1)->frequency();
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_continuous_src_time_get_fwidth (SCM s_0)
{
#define FUNC_NAME "meep-continuous-src-time-get-fwidth"
  meep::continuous_src_time *arg1 = (meep::continuous_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::continuous_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__continuous_src_time, 1, 0);
  }
  result = (double)((meep::continuous_src_time const *)arg1)->get_fwidth();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_continuous_src_time_set_frequency (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-continuous-src-time-set-frequency"
  meep::continuous_src_time *arg1 = (meep::continuous_src_time *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::continuous_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__continuous_src_time, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->set_frequency(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_custom_src_time__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-custom-src-time"
  std::complex< double > (*arg1)(double,void *) = (std::complex< double > (*)(double,void *)) 0 ;
  void *arg2 = (void *) 0 ;
  double arg3 ;
  double arg4 ;
  std::complex< double > arg5 ;
  double arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::custom_src_time *result = 0 ;
  
  {
    arg1 = my_complex_func2;
    arg2 = (void *) argv[0]; // input is SCM pointer to Scheme function
  }
  {
    arg3 = (double) scm_to_double(argv[1]);
  }
  {
    arg4 = (double) scm_to_double(argv[2]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[3]);
    arg5 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg6 = (double) scm_to_double(argv[4]);
  }
  result = (meep::custom_src_time *)new meep::custom_src_time(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__custom_src_time, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_custom_src_time__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-custom-src-time"
  std::complex< double > (*arg1)(double,void *) = (std::complex< double > (*)(double,void *)) 0 ;
  void *arg2 = (void *) 0 ;
  double arg3 ;
  double arg4 ;
  std::complex< double > arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::custom_src_time *result = 0 ;
  
  {
    arg1 = my_complex_func2;
    arg2 = (void *) argv[0]; // input is SCM pointer to Scheme function
  }
  {
    arg3 = (double) scm_to_double(argv[1]);
  }
  {
    arg4 = (double) scm_to_double(argv[2]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[3]);
    arg5 = std::complex<double>(cnum.re, cnum.im);
  }
  result = (meep::custom_src_time *)new meep::custom_src_time(arg1,arg2,arg3,arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__custom_src_time, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_custom_src_time__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-custom-src-time"
  std::complex< double > (*arg1)(double,void *) = (std::complex< double > (*)(double,void *)) 0 ;
  void *arg2 = (void *) 0 ;
  double arg3 ;
  double arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::custom_src_time *result = 0 ;
  
  {
    arg1 = my_complex_func2;
    arg2 = (void *) argv[0]; // input is SCM pointer to Scheme function
  }
  {
    arg3 = (double) scm_to_double(argv[1]);
  }
  {
    arg4 = (double) scm_to_double(argv[2]);
  }
  result = (meep::custom_src_time *)new meep::custom_src_time(arg1,arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__custom_src_time, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_custom_src_time__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-custom-src-time"
  std::complex< double > (*arg1)(double,void *) = (std::complex< double > (*)(double,void *)) 0 ;
  void *arg2 = (void *) 0 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::custom_src_time *result = 0 ;
  
  {
    arg1 = my_complex_func2;
    arg2 = (void *) argv[0]; // input is SCM pointer to Scheme function
  }
  {
    arg3 = (double) scm_to_double(argv[1]);
  }
  result = (meep::custom_src_time *)new meep::custom_src_time(arg1,arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__custom_src_time, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_custom_src_time__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-custom-src-time"
  std::complex< double > (*arg1)(double,void *) = (std::complex< double > (*)(double,void *)) 0 ;
  void *arg2 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::custom_src_time *result = 0 ;
  
  {
    arg1 = my_complex_func2;
    arg2 = (void *) argv[0]; // input is SCM pointer to Scheme function
  }
  result = (meep::custom_src_time *)new meep::custom_src_time(arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__custom_src_time, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_custom_src_time(SCM rest)
{
#define FUNC_NAME "new-meep-custom-src-time"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "new-meep-custom-src-time");
  if (argc == 1) {
    int _v;
    {
      _v = SCM_NFALSEP(scm_procedure_p(argv[0]));
    }
    if (_v) {
      if (argc <= 1) {
        return _wrap_new_meep_custom_src_time__SWIG_4(argc,argv);
      }
      return _wrap_new_meep_custom_src_time__SWIG_4(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = SCM_NFALSEP(scm_procedure_p(argv[0]));
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_new_meep_custom_src_time__SWIG_3(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = SCM_NFALSEP(scm_procedure_p(argv[0]));
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_new_meep_custom_src_time__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      _v = SCM_NFALSEP(scm_procedure_p(argv[0]));
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigComplex_Check(argv[3]);
          }
          if (_v) {
            return _wrap_new_meep_custom_src_time__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = SCM_NFALSEP(scm_procedure_p(argv[0]));
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigComplex_Check(argv[3]);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_new_meep_custom_src_time__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-custom-src-time", "No matching method for generic function `new_meep_custom_src_time'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_custom_src_time (SCM s_0)
{
#define FUNC_NAME "delete-meep-custom-src-time"
  meep::custom_src_time *arg1 = (meep::custom_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::custom_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__custom_src_time, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_custom_src_time_current (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-custom-src-time-current"
  meep::custom_src_time *arg1 = (meep::custom_src_time *) 0 ;
  double arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::custom_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__custom_src_time, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  result = ((meep::custom_src_time const *)arg1)->current(arg2,arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_custom_src_time_dipole (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-custom-src-time-dipole"
  meep::custom_src_time *arg1 = (meep::custom_src_time *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::custom_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__custom_src_time, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  result = ((meep::custom_src_time const *)arg1)->dipole(arg2);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_custom_src_time_last_time (SCM s_0)
{
#define FUNC_NAME "meep-custom-src-time-last-time"
  meep::custom_src_time *arg1 = (meep::custom_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::custom_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__custom_src_time, 1, 0);
  }
  result = (double)((meep::custom_src_time const *)arg1)->last_time();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_custom_src_time_clone (SCM s_0)
{
#define FUNC_NAME "meep-custom-src-time-clone"
  meep::custom_src_time *arg1 = (meep::custom_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::src_time *result = 0 ;
  
  {
    arg1 = (meep::custom_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__custom_src_time, 1, 0);
  }
  result = (meep::src_time *)((meep::custom_src_time const *)arg1)->clone();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__src_time, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_custom_src_time_is_equal (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-custom-src-time-is-equal"
  meep::custom_src_time *arg1 = (meep::custom_src_time *) 0 ;
  meep::src_time *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::custom_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__custom_src_time, 1, 0);
  }
  {
    arg2 = (meep::src_time *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__src_time, 2, 0);
  }
  result = (bool)((meep::custom_src_time const *)arg1)->is_equal((meep::src_time const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_custom_src_time_frequency (SCM s_0)
{
#define FUNC_NAME "meep-custom-src-time-frequency"
  meep::custom_src_time *arg1 = (meep::custom_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::custom_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__custom_src_time, 1, 0);
  }
  result = ((meep::custom_src_time const *)arg1)->frequency();
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_custom_src_time_set_frequency (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-custom-src-time-set-frequency"
  meep::custom_src_time *arg1 = (meep::custom_src_time *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::custom_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__custom_src_time, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->set_frequency(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_custom_src_time_get_fwidth (SCM s_0)
{
#define FUNC_NAME "meep-custom-src-time-get-fwidth"
  meep::custom_src_time *arg1 = (meep::custom_src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::custom_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__custom_src_time, 1, 0);
  }
  result = (double)((meep::custom_src_time const *)arg1)->get_fwidth();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_custom_src_time_set_fwidth (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-custom-src-time-set-fwidth"
  meep::custom_src_time *arg1 = (meep::custom_src_time *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::custom_src_time *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__custom_src_time, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  (arg1)->set_fwidth(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_monitor_point ()
{
#define FUNC_NAME "new-meep-monitor-point"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::monitor_point *result = 0 ;
  
  result = (meep::monitor_point *)new meep::monitor_point();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__monitor_point, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_monitor_point (SCM s_0)
{
#define FUNC_NAME "delete-meep-monitor-point"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_loc_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-monitor-point-loc-set"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  meep::vec *arg2 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  {
    arg2 = (meep::vec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__vec, 2, 0);
  }
  if (arg1) (arg1)->loc = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_loc_get (SCM s_0)
{
#define FUNC_NAME "meep-monitor-point-loc-get"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec *result = 0 ;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  result = (meep::vec *)& ((arg1)->loc);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__vec, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_t_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-monitor-point-t-set"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->t = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_t_get (SCM s_0)
{
#define FUNC_NAME "meep-monitor-point-t-get"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  result = (double) ((arg1)->t);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_f_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-monitor-point-f-set"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  std::complex< double > *arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  {
    arg2 = (std::complex< double > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__complexT_double_t, 2, 0);
  }
  {
    size_t ii;
    std::complex< double > *b = (std::complex< double > *) arg1->f;
    for (ii = 0; ii < (size_t)meep::NUM_FIELD_COMPONENTS; ii++) b[ii] = *((std::complex< double > *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_f_get (SCM s_0)
{
#define FUNC_NAME "meep-monitor-point-f-get"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > *result = 0 ;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  result = (std::complex< double > *)(std::complex< double > *) ((arg1)->f);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_next_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-monitor-point-next-set"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  meep::monitor_point *arg2 = (meep::monitor_point *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  {
    arg2 = (meep::monitor_point *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__monitor_point, 2, 0);
  }
  if (arg1) (arg1)->next = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_next_get (SCM s_0)
{
#define FUNC_NAME "meep-monitor-point-next-get"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::monitor_point *result = 0 ;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  result = (meep::monitor_point *) ((arg1)->next);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__monitor_point, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_get_component (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-monitor-point-get-component"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = (arg1)->get_component(arg2);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_poynting_in_direction__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-monitor-point-poynting-in-direction"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  result = (double)(arg1)->poynting_in_direction(arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_poynting_in_direction__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-monitor-point-poynting-in-direction"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  meep::vec arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  {
    arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  }
  result = (double)(arg1)->poynting_in_direction(arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_poynting_in_direction(SCM rest)
{
#define FUNC_NAME "meep-monitor-point-poynting-in-direction"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-monitor-point-poynting-in-direction");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__monitor_point, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_monitor_point_poynting_in_direction__SWIG_0(argc,argv);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__monitor_point, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        return _wrap_meep_monitor_point_poynting_in_direction__SWIG_1(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-monitor-point-poynting-in-direction", "No matching method for generic function `meep_monitor_point_poynting_in_direction'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_fourier_transform__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-monitor-point-fourier-transform"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  meep::component arg2 ;
  std::complex< double > **arg3 = (std::complex< double > **) 0 ;
  std::complex< double > **arg4 = (std::complex< double > **) 0 ;
  int *arg5 = (int *) 0 ;
  double arg6 ;
  double arg7 ;
  int arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (std::complex< double > **)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_p_std__complexT_double_t, 3, 0);
  }
  {
    arg4 = (std::complex< double > **)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_p_std__complexT_double_t, 4, 0);
  }
  {
    arg5 = (int *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_int, 5, 0);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (double) scm_to_double(argv[6]);
  }
  {
    arg8 = (int) scm_to_int(argv[7]);
  }
  (arg1)->fourier_transform(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_fourier_transform__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-monitor-point-fourier-transform"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  meep::component arg2 ;
  std::complex< double > **arg3 = (std::complex< double > **) 0 ;
  std::complex< double > **arg4 = (std::complex< double > **) 0 ;
  int *arg5 = (int *) 0 ;
  double arg6 ;
  double arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (std::complex< double > **)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_p_std__complexT_double_t, 3, 0);
  }
  {
    arg4 = (std::complex< double > **)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_p_std__complexT_double_t, 4, 0);
  }
  {
    arg5 = (int *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_int, 5, 0);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (double) scm_to_double(argv[6]);
  }
  (arg1)->fourier_transform(arg2,arg3,arg4,arg5,arg6,arg7);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_fourier_transform__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-monitor-point-fourier-transform"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  meep::component arg2 ;
  std::complex< double > **arg3 = (std::complex< double > **) 0 ;
  std::complex< double > **arg4 = (std::complex< double > **) 0 ;
  int *arg5 = (int *) 0 ;
  double arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (std::complex< double > **)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_p_std__complexT_double_t, 3, 0);
  }
  {
    arg4 = (std::complex< double > **)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_p_std__complexT_double_t, 4, 0);
  }
  {
    arg5 = (int *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_int, 5, 0);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  (arg1)->fourier_transform(arg2,arg3,arg4,arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_fourier_transform__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-monitor-point-fourier-transform"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  meep::component arg2 ;
  std::complex< double > **arg3 = (std::complex< double > **) 0 ;
  std::complex< double > **arg4 = (std::complex< double > **) 0 ;
  int *arg5 = (int *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (std::complex< double > **)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_p_std__complexT_double_t, 3, 0);
  }
  {
    arg4 = (std::complex< double > **)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_p_std__complexT_double_t, 4, 0);
  }
  {
    arg5 = (int *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_int, 5, 0);
  }
  (arg1)->fourier_transform(arg2,arg3,arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_fourier_transform(SCM rest)
{
#define FUNC_NAME "meep-monitor-point-fourier-transform"
  SCM argv[8];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 8, "meep-monitor-point-fourier-transform");
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__monitor_point, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_monitor_point_fourier_transform__SWIG_3(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__monitor_point, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_monitor_point_fourier_transform__SWIG_2(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__monitor_point, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_monitor_point_fourier_transform__SWIG_1(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__monitor_point, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_integer_p(argv[7])) && scm_is_true(scm_exact_p(argv[7]))? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_monitor_point_fourier_transform__SWIG_0(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-monitor-point-fourier-transform", "No matching method for generic function `meep_monitor_point_fourier_transform'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_monitor_point_harminv (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5, SCM s_6, SCM s_7)
{
#define FUNC_NAME "meep-monitor-point-harminv"
  meep::monitor_point *arg1 = (meep::monitor_point *) 0 ;
  meep::component arg2 ;
  std::complex< double > **arg3 = (std::complex< double > **) 0 ;
  std::complex< double > **arg4 = (std::complex< double > **) 0 ;
  int *arg5 = (int *) 0 ;
  double arg6 ;
  double arg7 ;
  int arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::monitor_point *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__monitor_point, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (std::complex< double > **)SWIG_MustGetPtr(s_2, SWIGTYPE_p_p_std__complexT_double_t, 3, 0);
  }
  {
    arg4 = (std::complex< double > **)SWIG_MustGetPtr(s_3, SWIGTYPE_p_p_std__complexT_double_t, 4, 0);
  }
  {
    arg5 = (int *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_int, 5, 0);
  }
  {
    arg6 = (double) scm_to_double(s_5);
  }
  {
    arg7 = (double) scm_to_double(s_6);
  }
  {
    arg8 = (int) scm_to_int(s_7);
  }
  (arg1)->harminv(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_chunk (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5, SCM s_6, SCM s_7, SCM s_8, SCM s_9, SCM s_10, SCM s_11, SCM s_12, SCM s_13, SCM s_14, SCM s_15)
{
#define FUNC_NAME "new-meep-dft-chunk"
  meep::fields_chunk *arg1 = (meep::fields_chunk *) 0 ;
  meep::ivec arg2 ;
  meep::ivec arg3 ;
  meep::vec arg4 ;
  meep::vec arg5 ;
  meep::vec arg6 ;
  meep::vec arg7 ;
  double arg8 ;
  double arg9 ;
  meep::component arg10 ;
  bool arg11 ;
  std::complex< double > arg12 ;
  meep::ivec arg13 ;
  meep::symmetry *arg14 = 0 ;
  int arg15 ;
  void *arg16 = (void *) 0 ;
  meep::ivec *argp2 ;
  meep::ivec *argp3 ;
  meep::ivec *argp13 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields_chunk, 1, 0);
  }
  {
    argp2 = (meep::ivec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__ivec, 2, 0);
    arg2 = *argp2;
  }
  {
    argp3 = (meep::ivec *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__ivec, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = vector3_to_vec(ctl_convert_vector3_to_c(s_3));
  }
  {
    arg5 = vector3_to_vec(ctl_convert_vector3_to_c(s_4));
  }
  {
    arg6 = vector3_to_vec(ctl_convert_vector3_to_c(s_5));
  }
  {
    arg7 = vector3_to_vec(ctl_convert_vector3_to_c(s_6));
  }
  {
    arg8 = (double) scm_to_double(s_7);
  }
  {
    arg9 = (double) scm_to_double(s_8);
  }
  {
    arg10 = (meep::component) scm_to_int(s_9); 
  }
  {
    arg11 = (bool) scm_is_true(s_10);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_11);
    arg12 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    argp13 = (meep::ivec *)SWIG_MustGetPtr(s_12, SWIGTYPE_p_meep__ivec, 13, 0);
    arg13 = *argp13;
  }
  {
    arg14 = (meep::symmetry *)SWIG_MustGetPtr(s_13, SWIGTYPE_p_meep__symmetry, 14, 0);
  }
  {
    arg15 = (int) scm_to_int(s_14);
  }
  {
    arg16 = (void *)SWIG_MustGetPtr(s_15, NULL, 16, 0);
  }
  result = (meep::dft_chunk *)new meep::dft_chunk(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(meep::symmetry const &)*arg14,arg15,(void const *)arg16);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_chunk_rest (SCM rest)
{
SCM arg[16];
SWIG_Guile_GetArgs (arg, rest, 16, 0, "new-meep-dft-chunk");
return _wrap_new_meep_dft_chunk(arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9], arg[10], arg[11], arg[12], arg[13], arg[14], arg[15]);
}
static SCM
_wrap_delete_meep_dft_chunk (SCM s_0)
{
#define FUNC_NAME "delete-meep-dft-chunk"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_update_dft (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-update-dft"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  (arg1)->update_dft(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_norm2 (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-norm2"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::grid_volume arg2 ;
  meep::grid_volume *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    argp2 = (meep::grid_volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__grid_volume, 2, 0);
    arg2 = *argp2;
  }
  result = (double)((meep::dft_chunk const *)arg1)->norm2(arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_maxomega (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-maxomega"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (double)((meep::dft_chunk const *)arg1)->maxomega();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_scale_dft (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-scale-dft"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->scale_dft(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_process_dft_component (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5, SCM s_6, SCM s_7, SCM s_8, SCM s_9, SCM s_10, SCM s_11, SCM s_12, SCM s_13, SCM s_14)
{
#define FUNC_NAME "meep-dft-chunk-process-dft-component"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  int arg2 ;
  meep::direction *arg3 = (meep::direction *) 0 ;
  meep::ivec arg4 ;
  meep::ivec arg5 ;
  int arg6 ;
  meep::h5file *arg7 = (meep::h5file *) 0 ;
  meep::realnum *arg8 = (meep::realnum *) 0 ;
  int arg9 ;
  std::complex< meep::realnum > *arg10 = (std::complex< meep::realnum > *) 0 ;
  void *arg11 = (void *) 0 ;
  void *arg12 = (void *) 0 ;
  int arg13 ;
  bool arg14 ;
  meep::fields *arg15 = (meep::fields *) 0 ;
  meep::ivec *argp4 ;
  meep::ivec *argp5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  {
    arg3 = (meep::direction *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__direction, 3, 0);
  }
  {
    argp4 = (meep::ivec *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__ivec, 4, 0);
    arg4 = *argp4;
  }
  {
    argp5 = (meep::ivec *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_meep__ivec, 5, 0);
    arg5 = *argp5;
  }
  {
    arg6 = (int) scm_to_int(s_5);
  }
  {
    arg7 = (meep::h5file *)SWIG_MustGetPtr(s_6, SWIGTYPE_p_meep__h5file, 7, 0);
  }
  {
    arg8 = (meep::realnum *)SWIG_MustGetPtr(s_7, SWIGTYPE_p_double, 8, 0);
  }
  {
    arg9 = (int) scm_to_int(s_8);
  }
  {
    arg10 = (std::complex< meep::realnum > *)SWIG_MustGetPtr(s_9, SWIGTYPE_p_std__complexT_double_t, 10, 0);
  }
  {
    arg11 = (void *)SWIG_MustGetPtr(s_10, NULL, 11, 0);
  }
  {
    arg12 = (void *)SWIG_MustGetPtr(s_11, NULL, 12, 0);
  }
  {
    arg13 = (int) scm_to_int(s_12);
  }
  {
    arg14 = (bool) scm_is_true(s_13);
  }
  {
    arg15 = (meep::fields *)SWIG_MustGetPtr(s_14, SWIGTYPE_p_meep__fields, 15, 0);
  }
  result = (arg1)->process_dft_component(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_process_dft_component_rest (SCM rest)
{
SCM arg[15];
SWIG_Guile_GetArgs (arg, rest, 15, 0, "meep-dft-chunk-process-dft-component");
return _wrap_meep_dft_chunk_process_dft_component(arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9], arg[10], arg[11], arg[12], arg[13], arg[14]);
}
static SCM
_wrap_meep_dft_chunk_get_decimation_factor (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-get-decimation-factor"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (int)((meep::dft_chunk const *)arg1)->get_decimation_factor();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_meep_dft_chunk_subeq (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-meep-dft-chunk-subeq"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  (arg1)->operator -=((meep::dft_chunk const &)*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_omega_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-omega-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  std::vector< double > arg2 ;
  std::vector< double > *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    argp2 = (std::vector< double > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__vectorT_double_t, 2, 0);
    arg2 = *argp2;
  }
  if (arg1) (arg1)->omega = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_omega_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-omega-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< double > result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result =  ((arg1)->omega);
  {
    std::vector< double > * resultptr;
    resultptr = new std::vector< double >((const std::vector< double > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_double_t, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_persist_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-persist-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  bool arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (bool) scm_is_true(s_1);
  }
  if (arg1) (arg1)->persist = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_persist_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-persist-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (bool) ((arg1)->persist);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_c_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-c-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  if (arg1) (arg1)->c = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_c_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-c-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::component result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (meep::component) ((arg1)->c);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_N_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-N-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  size_t arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (size_t) scm_to_ulong(s_1);
  }
  if (arg1) (arg1)->N = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_N_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-N-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  size_t result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result =  ((arg1)->N);
  {
    gswig_result = scm_from_ulong(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_dft_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-dft-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  std::complex< meep::realnum > *arg2 = (std::complex< meep::realnum > *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (std::complex< meep::realnum > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__complexT_double_t, 2, 0);
  }
  if (arg1) (arg1)->dft = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_dft_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-dft-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (std::complex< meep::realnum > *) ((arg1)->dft);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_next_in_chunk_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-next-in-chunk-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  if (arg1) (arg1)->next_in_chunk = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_next_in_chunk_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-next-in-chunk-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (meep::dft_chunk *) ((arg1)->next_in_chunk);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_next_in_dft_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-next-in-dft-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  if (arg1) (arg1)->next_in_dft = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_next_in_dft_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-next-in-dft-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (meep::dft_chunk *) ((arg1)->next_in_dft);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_stored_weight_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-stored-weight-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  if (arg1) (arg1)->stored_weight = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_stored_weight_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-stored-weight-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result =  ((arg1)->stored_weight);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_include_dV_and_interp_weights_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-include-dV-and-interp-weights-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  bool arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (bool) scm_is_true(s_1);
  }
  if (arg1) (arg1)->include_dV_and_interp_weights = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_include_dV_and_interp_weights_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-include-dV-and-interp-weights-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (bool) ((arg1)->include_dV_and_interp_weights);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_sqrt_dV_and_interp_weights_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-sqrt-dV-and-interp-weights-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  bool arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (bool) scm_is_true(s_1);
  }
  if (arg1) (arg1)->sqrt_dV_and_interp_weights = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_sqrt_dV_and_interp_weights_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-sqrt-dV-and-interp-weights-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (bool) ((arg1)->sqrt_dV_and_interp_weights);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_extra_weight_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-extra-weight-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  if (arg1) (arg1)->extra_weight = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_extra_weight_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-extra-weight-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result =  ((arg1)->extra_weight);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_fc_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-fc-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::fields_chunk *arg2 = (meep::fields_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::fields_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__fields_chunk, 2, 0);
  }
  if (arg1) (arg1)->fc = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_fc_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-fc-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::fields_chunk *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (meep::fields_chunk *) ((arg1)->fc);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__fields_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_is_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-is-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::ivec *arg2 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__ivec, 2, 0);
  }
  if (arg1) (arg1)->is = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_is_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-is-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (meep::ivec *)& ((arg1)->is);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__ivec, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_ie_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-ie-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::ivec *arg2 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__ivec, 2, 0);
  }
  if (arg1) (arg1)->ie = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_ie_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-ie-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (meep::ivec *)& ((arg1)->ie);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__ivec, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_is_old_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-is-old-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::ivec *arg2 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__ivec, 2, 0);
  }
  if (arg1) (arg1)->is_old = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_is_old_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-is-old-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (meep::ivec *)& ((arg1)->is_old);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__ivec, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_ie_old_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-ie-old-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::ivec *arg2 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__ivec, 2, 0);
  }
  if (arg1) (arg1)->ie_old = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_ie_old_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-ie-old-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (meep::ivec *)& ((arg1)->ie_old);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__ivec, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_s0_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-s0-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::vec *arg2 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::vec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__vec, 2, 0);
  }
  if (arg1) (arg1)->s0 = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_s0_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-s0-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (meep::vec *)& ((arg1)->s0);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__vec, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_s1_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-s1-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::vec *arg2 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::vec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__vec, 2, 0);
  }
  if (arg1) (arg1)->s1 = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_s1_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-s1-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (meep::vec *)& ((arg1)->s1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__vec, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_e0_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-e0-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::vec *arg2 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::vec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__vec, 2, 0);
  }
  if (arg1) (arg1)->e0 = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_e0_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-e0-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (meep::vec *)& ((arg1)->e0);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__vec, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_e1_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-e1-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::vec *arg2 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::vec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__vec, 2, 0);
  }
  if (arg1) (arg1)->e1 = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_e1_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-e1-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (meep::vec *)& ((arg1)->e1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__vec, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_dV0_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-dV0-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->dV0 = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_dV0_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-dV0-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (double) ((arg1)->dV0);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_dV1_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-dV1-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->dV1 = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_dV1_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-dV1-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (double) ((arg1)->dV1);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_empty_dim_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-empty-dim-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  bool *arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (bool *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_bool, 2, 0);
  }
  {
    size_t ii;
    bool *b = (bool *) arg1->empty_dim;
    for (ii = 0; ii < (size_t)5; ii++) b[ii] = *((bool *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_empty_dim_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-empty-dim-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (bool *)(bool *) ((arg1)->empty_dim);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_bool, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_scale_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-scale-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  if (arg1) (arg1)->scale = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_scale_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-scale-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result =  ((arg1)->scale);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_shift_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-shift-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::ivec *arg2 = (meep::ivec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::ivec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__ivec, 2, 0);
  }
  if (arg1) (arg1)->shift = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_shift_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-shift-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (meep::ivec *)& ((arg1)->shift);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__ivec, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_S_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-S-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::symmetry *arg2 = (meep::symmetry *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::symmetry *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__symmetry, 2, 0);
  }
  if (arg1) (arg1)->S = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_S_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-S-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::symmetry *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (meep::symmetry *)& ((arg1)->S);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__symmetry, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_sn_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-sn-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  if (arg1) (arg1)->sn = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_sn_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-sn-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (int) ((arg1)->sn);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_dft_phase_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-dft-phase-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  std::complex< meep::realnum > *arg2 = (std::complex< meep::realnum > *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (std::complex< meep::realnum > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__complexT_double_t, 2, 0);
  }
  if (arg1) (arg1)->dft_phase = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_dft_phase_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-dft-phase-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (std::complex< meep::realnum > *) ((arg1)->dft_phase);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_avg1_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-avg1-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  ptrdiff_t arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (ptrdiff_t) scm_to_long(s_1);
  }
  if (arg1) (arg1)->avg1 = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_avg1_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-avg1-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ptrdiff_t result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result =  ((arg1)->avg1);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_avg2_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-avg2-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  ptrdiff_t arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (ptrdiff_t) scm_to_long(s_1);
  }
  if (arg1) (arg1)->avg2 = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_avg2_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-avg2-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ptrdiff_t result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result =  ((arg1)->avg2);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_vc_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-chunk-vc-set"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  if (arg1) (arg1)->vc = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_chunk_vc_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-chunk-vc-get"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  result = (int) ((arg1)->vc);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_save_dft_hdf5__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-save-dft-hdf5"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::component arg2 ;
  meep::h5file *arg3 = (meep::h5file *) 0 ;
  char *arg4 = (char *) 0 ;
  bool arg5 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::h5file *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__h5file, 3, 0);
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  meep::save_dft_hdf5(arg1,arg2,arg3,(char const *)arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_save_dft_hdf5__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-save-dft-hdf5"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::component arg2 ;
  meep::h5file *arg3 = (meep::h5file *) 0 ;
  char *arg4 = (char *) 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::h5file *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__h5file, 3, 0);
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  meep::save_dft_hdf5(arg1,arg2,arg3,(char const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_save_dft_hdf5__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-save-dft-hdf5"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::component arg2 ;
  meep::h5file *arg3 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::h5file *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__h5file, 3, 0);
  }
  meep::save_dft_hdf5(arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_load_dft_hdf5__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-load-dft-hdf5"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::component arg2 ;
  meep::h5file *arg3 = (meep::h5file *) 0 ;
  char *arg4 = (char *) 0 ;
  bool arg5 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::h5file *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__h5file, 3, 0);
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  meep::load_dft_hdf5(arg1,arg2,arg3,(char const *)arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_load_dft_hdf5__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-load-dft-hdf5"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::component arg2 ;
  meep::h5file *arg3 = (meep::h5file *) 0 ;
  char *arg4 = (char *) 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::h5file *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__h5file, 3, 0);
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  meep::load_dft_hdf5(arg1,arg2,arg3,(char const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_load_dft_hdf5__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-load-dft-hdf5"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::component arg2 ;
  meep::h5file *arg3 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::h5file *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__h5file, 3, 0);
  }
  meep::load_dft_hdf5(arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_save_dft_hdf5__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-save-dft-hdf5"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  char *arg2 = (char *) 0 ;
  meep::h5file *arg3 = (meep::h5file *) 0 ;
  char *arg4 = (char *) 0 ;
  bool arg5 ;
  int must_free2 = 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (meep::h5file *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__h5file, 3, 0);
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  meep::save_dft_hdf5(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_save_dft_hdf5__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-save-dft-hdf5"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  char *arg2 = (char *) 0 ;
  meep::h5file *arg3 = (meep::h5file *) 0 ;
  char *arg4 = (char *) 0 ;
  int must_free2 = 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (meep::h5file *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__h5file, 3, 0);
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  meep::save_dft_hdf5(arg1,(char const *)arg2,arg3,(char const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_save_dft_hdf5__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-save-dft-hdf5"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  char *arg2 = (char *) 0 ;
  meep::h5file *arg3 = (meep::h5file *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (meep::h5file *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__h5file, 3, 0);
  }
  meep::save_dft_hdf5(arg1,(char const *)arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_save_dft_hdf5(SCM rest)
{
#define FUNC_NAME "meep-save-dft-hdf5"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-save-dft-hdf5");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__h5file, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_save_dft_hdf5__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__h5file, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_save_dft_hdf5__SWIG_5(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__h5file, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_save_dft_hdf5__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__h5file, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_save_dft_hdf5__SWIG_4(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__h5file, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_save_dft_hdf5__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__h5file, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_save_dft_hdf5__SWIG_3(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-save-dft-hdf5", "No matching method for generic function `meep_save_dft_hdf5'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_load_dft_hdf5__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-load-dft-hdf5"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  char *arg2 = (char *) 0 ;
  meep::h5file *arg3 = (meep::h5file *) 0 ;
  char *arg4 = (char *) 0 ;
  bool arg5 ;
  int must_free2 = 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (meep::h5file *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__h5file, 3, 0);
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  meep::load_dft_hdf5(arg1,(char const *)arg2,arg3,(char const *)arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_load_dft_hdf5__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-load-dft-hdf5"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  char *arg2 = (char *) 0 ;
  meep::h5file *arg3 = (meep::h5file *) 0 ;
  char *arg4 = (char *) 0 ;
  int must_free2 = 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (meep::h5file *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__h5file, 3, 0);
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  meep::load_dft_hdf5(arg1,(char const *)arg2,arg3,(char const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_load_dft_hdf5__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-load-dft-hdf5"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  char *arg2 = (char *) 0 ;
  meep::h5file *arg3 = (meep::h5file *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (meep::h5file *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__h5file, 3, 0);
  }
  meep::load_dft_hdf5(arg1,(char const *)arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_load_dft_hdf5(SCM rest)
{
#define FUNC_NAME "meep-load-dft-hdf5"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-load-dft-hdf5");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__h5file, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_load_dft_hdf5__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__h5file, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_load_dft_hdf5__SWIG_5(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__h5file, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_load_dft_hdf5__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__h5file, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_load_dft_hdf5__SWIG_4(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__h5file, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_load_dft_hdf5__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__h5file, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_load_dft_hdf5__SWIG_3(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-load-dft-hdf5", "No matching method for generic function `meep_load_dft_hdf5'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_flux__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-flux"
  meep::component arg1 ;
  meep::component arg2 ;
  meep::dft_chunk *arg3 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg4 = (meep::dft_chunk *) 0 ;
  double arg5 ;
  double arg6 ;
  int arg7 ;
  meep::volume *arg8 = 0 ;
  meep::direction arg9 ;
  bool arg10 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_flux *result = 0 ;
  
  {
    arg1 = (meep::component const) scm_to_int(argv[0]); 
  }
  {
    arg2 = (meep::component const) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__dft_chunk, 3, 0);
  }
  {
    arg4 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__dft_chunk, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (int) scm_to_int(argv[6]);
  }
  {
    arg8 = (meep::volume *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__volume, 8, 0);
  }
  {
    arg9 = (meep::direction) scm_to_int(argv[8]); 
  }
  {
    arg10 = (bool) scm_is_true(argv[9]);
  }
  result = (meep::dft_flux *)new meep::dft_flux(arg1,arg2,arg3,arg4,arg5,arg6,arg7,(meep::volume const &)*arg8,arg9,arg10);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_flux__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-flux"
  meep::component arg1 ;
  meep::component arg2 ;
  meep::dft_chunk *arg3 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg4 = (meep::dft_chunk *) 0 ;
  std::vector< double > *arg5 = 0 ;
  meep::volume *arg6 = 0 ;
  meep::direction arg7 ;
  bool arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_flux *result = 0 ;
  
  {
    arg1 = (meep::component const) scm_to_int(argv[0]); 
  }
  {
    arg2 = (meep::component const) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__dft_chunk, 3, 0);
  }
  {
    arg4 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__dft_chunk, 4, 0);
  }
  {
    arg5 = (std::vector< double > *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_std__vectorT_double_t, 5, 0);
  }
  {
    arg6 = (meep::volume *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__volume, 6, 0);
  }
  {
    arg7 = (meep::direction) scm_to_int(argv[6]); 
  }
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  result = (meep::dft_flux *)new meep::dft_flux(arg1,arg2,arg3,arg4,(std::vector< double > const &)*arg5,(meep::volume const &)*arg6,arg7,arg8);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_flux__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-flux"
  meep::component arg1 ;
  meep::component arg2 ;
  meep::dft_chunk *arg3 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg4 = (meep::dft_chunk *) 0 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  meep::volume *arg7 = 0 ;
  meep::direction arg8 ;
  bool arg9 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_flux *result = 0 ;
  
  {
    arg1 = (meep::component const) scm_to_int(argv[0]); 
  }
  {
    arg2 = (meep::component const) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__dft_chunk, 3, 0);
  }
  {
    arg4 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__dft_chunk, 4, 0);
  }
  {
    arg5 = (double *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_double, 5, 0);
  }
  {
    arg6 = (size_t) scm_to_ulong(argv[5]);
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__volume, 7, 0);
  }
  {
    arg8 = (meep::direction) scm_to_int(argv[7]); 
  }
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  result = (meep::dft_flux *)new meep::dft_flux(arg1,arg2,arg3,arg4,(double const *)arg5,arg6,(meep::volume const &)*arg7,arg8,arg9);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_flux__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-flux"
  meep::dft_flux *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_flux *result = 0 ;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  result = (meep::dft_flux *)new meep::dft_flux((meep::dft_flux const &)*arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_flux(SCM rest)
{
#define FUNC_NAME "new-meep-dft-flux"
  SCM argv[10];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 10, "new-meep-dft-flux");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_flux, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_dft_flux__SWIG_3(argc,argv);
    }
  }
  if (argc == 8) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_new_meep_dft_flux__SWIG_1(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_integer_p(argv[7])) && scm_is_true(scm_exact_p(argv[7]))? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      return _wrap_new_meep_dft_flux__SWIG_2(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_integer_p(argv[8])) && scm_is_true(scm_exact_p(argv[8]))? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = SCM_BOOLP(argv[9]) ? 1 : 0;
                      }
                      if (_v) {
                        return _wrap_new_meep_dft_flux__SWIG_0(argc,argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-dft-flux", "No matching method for generic function `new_meep_dft_flux'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_flux (SCM s_0)
{
#define FUNC_NAME "meep-dft-flux-flux"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double *result = 0 ;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  result = (double *)(arg1)->flux();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_save_hdf5__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-flux-save-hdf5"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->save_hdf5(arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_save_hdf5__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-flux-save-hdf5"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  (arg1)->save_hdf5(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_load_hdf5__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-flux-load-hdf5"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->load_hdf5(arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_load_hdf5__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-flux-load-hdf5"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  (arg1)->load_hdf5(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_meep_dft_flux_subeq (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-flux-meep-dft-flux-subeq"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::dft_flux *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::dft_flux *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_flux, 2, 0);
  }
  (arg1)->operator -=((meep::dft_flux const &)*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_save_hdf5__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-flux-save-hdf5"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  int must_free5 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  {
    arg5 = (char *)SWIG_scm2str(argv[4]);
    must_free5 = 1;
  }
  (arg1)->save_hdf5(*arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  if (must_free5 && arg5) SWIG_free(arg5);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_save_hdf5__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-flux-save-hdf5"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  (arg1)->save_hdf5(*arg2,(char const *)arg3,(char const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_save_hdf5__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-flux-save-hdf5"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->save_hdf5(*arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_save_hdf5(SCM rest)
{
#define FUNC_NAME "meep-dft-flux-save-hdf5"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-dft-flux-save-hdf5");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_flux, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_dft_flux_save_hdf5__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_flux, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_flux_save_hdf5__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_flux, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_flux_save_hdf5__SWIG_4(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_flux, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_dft_flux_save_hdf5__SWIG_3(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_flux, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_string(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_dft_flux_save_hdf5__SWIG_2(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-dft-flux-save-hdf5", "No matching method for generic function `meep_dft_flux_save_hdf5'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_load_hdf5__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-flux-load-hdf5"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  int must_free5 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  {
    arg5 = (char *)SWIG_scm2str(argv[4]);
    must_free5 = 1;
  }
  (arg1)->load_hdf5(*arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  if (must_free5 && arg5) SWIG_free(arg5);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_load_hdf5__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-flux-load-hdf5"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  (arg1)->load_hdf5(*arg2,(char const *)arg3,(char const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_load_hdf5__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-flux-load-hdf5"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->load_hdf5(*arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_load_hdf5(SCM rest)
{
#define FUNC_NAME "meep-dft-flux-load-hdf5"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-dft-flux-load-hdf5");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_flux, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_dft_flux_load_hdf5__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_flux, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_flux_load_hdf5__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_flux, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_flux_load_hdf5__SWIG_4(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_flux, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_dft_flux_load_hdf5__SWIG_3(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_flux, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_string(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_dft_flux_load_hdf5__SWIG_2(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-dft-flux-load-hdf5", "No matching method for generic function `meep_dft_flux_load_hdf5'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_scale_dfts (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-flux-scale-dfts"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->scale_dfts(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_remove (SCM s_0)
{
#define FUNC_NAME "meep-dft-flux-remove"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  (arg1)->remove();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_freq_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-flux-freq-set"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  std::vector< double > arg2 ;
  std::vector< double > *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    argp2 = (std::vector< double > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__vectorT_double_t, 2, 0);
    arg2 = *argp2;
  }
  if (arg1) (arg1)->freq = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_freq_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-flux-freq-get"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< double > result;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  result =  ((arg1)->freq);
  {
    std::vector< double > * resultptr;
    resultptr = new std::vector< double >((const std::vector< double > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_double_t, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_E_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-flux-E-set"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  if (arg1) (arg1)->E = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_E_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-flux-E-get"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  result = (meep::dft_chunk *) ((arg1)->E);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_H_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-flux-H-set"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  if (arg1) (arg1)->H = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_H_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-flux-H-get"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  result = (meep::dft_chunk *) ((arg1)->H);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_cE_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-flux-cE-set"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  if (arg1) (arg1)->cE = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_cE_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-flux-cE-get"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::component result;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  result = (meep::component) ((arg1)->cE);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_cH_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-flux-cH-set"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  if (arg1) (arg1)->cH = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_cH_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-flux-cH-get"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::component result;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  result = (meep::component) ((arg1)->cH);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_where_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-flux-where-set"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::volume *arg2 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  if (arg1) (arg1)->where = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_where_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-flux-where-get"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume *result = 0 ;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  result = (meep::volume *)& ((arg1)->where);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_normal_direction_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-flux-normal-direction-set"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  if (arg1) (arg1)->normal_direction = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_normal_direction_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-flux-normal-direction-get"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::direction result;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  result = (meep::direction) ((arg1)->normal_direction);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_use_symmetry_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-flux-use-symmetry-set"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  bool arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  {
    arg2 = (bool) scm_is_true(s_1);
  }
  if (arg1) (arg1)->use_symmetry = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_flux_use_symmetry_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-flux-use-symmetry-get"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  result = (bool) ((arg1)->use_symmetry);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_dft_flux (SCM s_0)
{
#define FUNC_NAME "delete-meep-dft-flux"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_energy__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-energy"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg3 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg4 = (meep::dft_chunk *) 0 ;
  double arg5 ;
  double arg6 ;
  int arg7 ;
  meep::volume *arg8 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_energy *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__dft_chunk, 3, 0);
  }
  {
    arg4 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__dft_chunk, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (int) scm_to_int(argv[6]);
  }
  {
    arg8 = (meep::volume *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__volume, 8, 0);
  }
  result = (meep::dft_energy *)new meep::dft_energy(arg1,arg2,arg3,arg4,arg5,arg6,arg7,(meep::volume const &)*arg8);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_energy, 1);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_energy__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-energy"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg3 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg4 = (meep::dft_chunk *) 0 ;
  std::vector< double > *arg5 = 0 ;
  meep::volume *arg6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_energy *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__dft_chunk, 3, 0);
  }
  {
    arg4 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__dft_chunk, 4, 0);
  }
  {
    arg5 = (std::vector< double > *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_std__vectorT_double_t, 5, 0);
  }
  {
    arg6 = (meep::volume *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__volume, 6, 0);
  }
  result = (meep::dft_energy *)new meep::dft_energy(arg1,arg2,arg3,arg4,(std::vector< double > const &)*arg5,(meep::volume const &)*arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_energy, 1);
  }
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_energy__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-energy"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg3 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg4 = (meep::dft_chunk *) 0 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  meep::volume *arg7 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_energy *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__dft_chunk, 3, 0);
  }
  {
    arg4 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__dft_chunk, 4, 0);
  }
  {
    arg5 = (double *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_double, 5, 0);
  }
  {
    arg6 = (size_t) scm_to_ulong(argv[5]);
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__volume, 7, 0);
  }
  result = (meep::dft_energy *)new meep::dft_energy(arg1,arg2,arg3,arg4,(double const *)arg5,arg6,(meep::volume const &)*arg7);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_energy, 1);
  }
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_energy__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-energy"
  meep::dft_energy *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_energy *result = 0 ;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  result = (meep::dft_energy *)new meep::dft_energy((meep::dft_energy const &)*arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_energy, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_energy(SCM rest)
{
#define FUNC_NAME "new-meep-dft-energy"
  SCM argv[8];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 8, "new-meep-dft-energy");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_energy, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_dft_energy__SWIG_3(argc,argv);
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_meep_dft_energy__SWIG_1(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_meep_dft_energy__SWIG_2(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_meep_dft_energy__SWIG_0(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-dft-energy", "No matching method for generic function `new_meep_dft_energy'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_electric (SCM s_0)
{
#define FUNC_NAME "meep-dft-energy-electric"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double *result = 0 ;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  result = (double *)(arg1)->electric();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_magnetic (SCM s_0)
{
#define FUNC_NAME "meep-dft-energy-magnetic"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double *result = 0 ;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  result = (double *)(arg1)->magnetic();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_total (SCM s_0)
{
#define FUNC_NAME "meep-dft-energy-total"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double *result = 0 ;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  result = (double *)(arg1)->total();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_save_hdf5__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-energy-save-hdf5"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->save_hdf5(arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_save_hdf5__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-energy-save-hdf5"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  (arg1)->save_hdf5(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_load_hdf5__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-energy-load-hdf5"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->load_hdf5(arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_load_hdf5__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-energy-load-hdf5"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  (arg1)->load_hdf5(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_save_hdf5__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-energy-save-hdf5"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  int must_free5 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  {
    arg5 = (char *)SWIG_scm2str(argv[4]);
    must_free5 = 1;
  }
  (arg1)->save_hdf5(*arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  if (must_free5 && arg5) SWIG_free(arg5);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_save_hdf5__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-energy-save-hdf5"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  (arg1)->save_hdf5(*arg2,(char const *)arg3,(char const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_save_hdf5__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-energy-save-hdf5"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->save_hdf5(*arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_save_hdf5(SCM rest)
{
#define FUNC_NAME "meep-dft-energy-save-hdf5"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-dft-energy-save-hdf5");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_energy, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_dft_energy_save_hdf5__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_energy, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_energy_save_hdf5__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_energy, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_energy_save_hdf5__SWIG_4(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_energy, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_dft_energy_save_hdf5__SWIG_3(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_energy, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_string(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_dft_energy_save_hdf5__SWIG_2(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-dft-energy-save-hdf5", "No matching method for generic function `meep_dft_energy_save_hdf5'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_load_hdf5__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-energy-load-hdf5"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  int must_free5 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  {
    arg5 = (char *)SWIG_scm2str(argv[4]);
    must_free5 = 1;
  }
  (arg1)->load_hdf5(*arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  if (must_free5 && arg5) SWIG_free(arg5);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_load_hdf5__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-energy-load-hdf5"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  (arg1)->load_hdf5(*arg2,(char const *)arg3,(char const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_load_hdf5__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-energy-load-hdf5"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->load_hdf5(*arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_load_hdf5(SCM rest)
{
#define FUNC_NAME "meep-dft-energy-load-hdf5"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-dft-energy-load-hdf5");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_energy, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_dft_energy_load_hdf5__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_energy, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_energy_load_hdf5__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_energy, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_energy_load_hdf5__SWIG_4(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_energy, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_dft_energy_load_hdf5__SWIG_3(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_energy, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_string(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_dft_energy_load_hdf5__SWIG_2(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-dft-energy-load-hdf5", "No matching method for generic function `meep_dft_energy_load_hdf5'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_scale_dfts (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-energy-scale-dfts"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->scale_dfts(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_remove (SCM s_0)
{
#define FUNC_NAME "meep-dft-energy-remove"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  (arg1)->remove();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_freq_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-energy-freq-set"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  std::vector< double > arg2 ;
  std::vector< double > *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    argp2 = (std::vector< double > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__vectorT_double_t, 2, 0);
    arg2 = *argp2;
  }
  if (arg1) (arg1)->freq = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_freq_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-energy-freq-get"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< double > result;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  result =  ((arg1)->freq);
  {
    std::vector< double > * resultptr;
    resultptr = new std::vector< double >((const std::vector< double > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_double_t, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_E_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-energy-E-set"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  if (arg1) (arg1)->E = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_E_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-energy-E-get"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  result = (meep::dft_chunk *) ((arg1)->E);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_H_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-energy-H-set"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  if (arg1) (arg1)->H = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_H_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-energy-H-get"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  result = (meep::dft_chunk *) ((arg1)->H);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_D_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-energy-D-set"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  if (arg1) (arg1)->D = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_D_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-energy-D-get"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  result = (meep::dft_chunk *) ((arg1)->D);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_B_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-energy-B-set"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  if (arg1) (arg1)->B = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_B_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-energy-B-get"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  result = (meep::dft_chunk *) ((arg1)->B);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_where_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-energy-where-set"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  meep::volume *arg2 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  if (arg1) (arg1)->where = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_energy_where_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-energy-where-get"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume *result = 0 ;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  result = (meep::volume *)& ((arg1)->where);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_dft_energy (SCM s_0)
{
#define FUNC_NAME "delete-meep-dft-energy"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_force__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-force"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg3 = (meep::dft_chunk *) 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  meep::volume *arg7 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_force *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__dft_chunk, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__volume, 7, 0);
  }
  result = (meep::dft_force *)new meep::dft_force(arg1,arg2,arg3,arg4,arg5,arg6,(meep::volume const &)*arg7);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_force, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_force__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-force"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg3 = (meep::dft_chunk *) 0 ;
  std::vector< double > *arg4 = 0 ;
  meep::volume *arg5 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_force *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__dft_chunk, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (meep::volume *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__volume, 5, 0);
  }
  result = (meep::dft_force *)new meep::dft_force(arg1,arg2,arg3,(std::vector< double > const &)*arg4,(meep::volume const &)*arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_force, 1);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_force__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-force"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  meep::dft_chunk *arg3 = (meep::dft_chunk *) 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  meep::volume *arg6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_force *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__dft_chunk, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (meep::volume *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__volume, 6, 0);
  }
  result = (meep::dft_force *)new meep::dft_force(arg1,arg2,arg3,(double const *)arg4,arg5,(meep::volume const &)*arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_force, 1);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_force__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-force"
  meep::dft_force *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_force *result = 0 ;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  result = (meep::dft_force *)new meep::dft_force((meep::dft_force const &)*arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_force, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_force(SCM rest)
{
#define FUNC_NAME "new-meep-dft-force"
  SCM argv[7];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 7, "new-meep-dft-force");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_force, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_dft_force__SWIG_3(argc,argv);
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_meep_dft_force__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_meep_dft_force__SWIG_2(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_meep_dft_force__SWIG_0(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-dft-force", "No matching method for generic function `new_meep_dft_force'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_force (SCM s_0)
{
#define FUNC_NAME "meep-dft-force-force"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double *result = 0 ;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  result = (double *)(arg1)->force();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_save_hdf5__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-force-save-hdf5"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->save_hdf5(arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_save_hdf5__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-force-save-hdf5"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  (arg1)->save_hdf5(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_load_hdf5__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-force-load-hdf5"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->load_hdf5(arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_load_hdf5__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-force-load-hdf5"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  (arg1)->load_hdf5(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_save_hdf5__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-force-save-hdf5"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  int must_free5 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  {
    arg5 = (char *)SWIG_scm2str(argv[4]);
    must_free5 = 1;
  }
  (arg1)->save_hdf5(*arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  if (must_free5 && arg5) SWIG_free(arg5);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_save_hdf5__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-force-save-hdf5"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  (arg1)->save_hdf5(*arg2,(char const *)arg3,(char const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_save_hdf5__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-force-save-hdf5"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->save_hdf5(*arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_save_hdf5(SCM rest)
{
#define FUNC_NAME "meep-dft-force-save-hdf5"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-dft-force-save-hdf5");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_force, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_dft_force_save_hdf5__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_force, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_force_save_hdf5__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_force, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_force_save_hdf5__SWIG_4(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_force, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_dft_force_save_hdf5__SWIG_3(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_force, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_string(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_dft_force_save_hdf5__SWIG_2(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-dft-force-save-hdf5", "No matching method for generic function `meep_dft_force_save_hdf5'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_load_hdf5__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-force-load-hdf5"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  int must_free5 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  {
    arg5 = (char *)SWIG_scm2str(argv[4]);
    must_free5 = 1;
  }
  (arg1)->load_hdf5(*arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  if (must_free5 && arg5) SWIG_free(arg5);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_load_hdf5__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-force-load-hdf5"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  (arg1)->load_hdf5(*arg2,(char const *)arg3,(char const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_load_hdf5__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-force-load-hdf5"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->load_hdf5(*arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_load_hdf5(SCM rest)
{
#define FUNC_NAME "meep-dft-force-load-hdf5"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-dft-force-load-hdf5");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_force, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_dft_force_load_hdf5__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_force, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_force_load_hdf5__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_force, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_force_load_hdf5__SWIG_4(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_force, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_dft_force_load_hdf5__SWIG_3(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_force, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_string(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_dft_force_load_hdf5__SWIG_2(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-dft-force-load-hdf5", "No matching method for generic function `meep_dft_force_load_hdf5'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_scale_dfts (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-force-scale-dfts"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->scale_dfts(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_remove (SCM s_0)
{
#define FUNC_NAME "meep-dft-force-remove"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  (arg1)->remove();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_freq_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-force-freq-set"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  std::vector< double > arg2 ;
  std::vector< double > *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    argp2 = (std::vector< double > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__vectorT_double_t, 2, 0);
    arg2 = *argp2;
  }
  if (arg1) (arg1)->freq = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_freq_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-force-freq-get"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< double > result;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  result =  ((arg1)->freq);
  {
    std::vector< double > * resultptr;
    resultptr = new std::vector< double >((const std::vector< double > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_double_t, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_offdiag1_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-force-offdiag1-set"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  if (arg1) (arg1)->offdiag1 = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_offdiag1_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-force-offdiag1-get"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  result = (meep::dft_chunk *) ((arg1)->offdiag1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_offdiag2_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-force-offdiag2-set"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  if (arg1) (arg1)->offdiag2 = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_offdiag2_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-force-offdiag2-get"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  result = (meep::dft_chunk *) ((arg1)->offdiag2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_diag_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-force-diag-set"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  if (arg1) (arg1)->diag = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_diag_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-force-diag-get"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  result = (meep::dft_chunk *) ((arg1)->diag);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_where_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-force-where-set"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  meep::volume *arg2 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  if (arg1) (arg1)->where = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_force_where_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-force-where-get"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume *result = 0 ;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  result = (meep::volume *)& ((arg1)->where);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_dft_force (SCM s_0)
{
#define FUNC_NAME "delete-meep-dft-force"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_sourcedata_near_fd_comp_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "sourcedata-near-fd-comp-set"
  meep::sourcedata *arg1 = (meep::sourcedata *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::sourcedata *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__sourcedata, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  if (arg1) (arg1)->near_fd_comp = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_sourcedata_near_fd_comp_get (SCM s_0)
{
#define FUNC_NAME "sourcedata-near-fd-comp-get"
  meep::sourcedata *arg1 = (meep::sourcedata *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::component result;
  
  {
    arg1 = (meep::sourcedata *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__sourcedata, 1, 0);
  }
  result = (meep::component) ((arg1)->near_fd_comp);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_sourcedata_idx_arr_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "sourcedata-idx-arr-set"
  meep::sourcedata *arg1 = (meep::sourcedata *) 0 ;
  std::vector< ptrdiff_t > arg2 ;
  std::vector< ptrdiff_t > *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::sourcedata *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__sourcedata, 1, 0);
  }
  {
    argp2 = (std::vector< ptrdiff_t > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__vectorT_ptrdiff_t_t, 2, 0);
    arg2 = *argp2;
  }
  if (arg1) (arg1)->idx_arr = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_sourcedata_idx_arr_get (SCM s_0)
{
#define FUNC_NAME "sourcedata-idx-arr-get"
  meep::sourcedata *arg1 = (meep::sourcedata *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< ptrdiff_t > result;
  
  {
    arg1 = (meep::sourcedata *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__sourcedata, 1, 0);
  }
  result =  ((arg1)->idx_arr);
  {
    std::vector< ptrdiff_t > * resultptr;
    resultptr = new std::vector< ptrdiff_t >((const std::vector< ptrdiff_t > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_ptrdiff_t_t, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_sourcedata_fc_idx_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "sourcedata-fc-idx-set"
  meep::sourcedata *arg1 = (meep::sourcedata *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::sourcedata *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__sourcedata, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  if (arg1) (arg1)->fc_idx = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_sourcedata_fc_idx_get (SCM s_0)
{
#define FUNC_NAME "sourcedata-fc-idx-get"
  meep::sourcedata *arg1 = (meep::sourcedata *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::sourcedata *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__sourcedata, 1, 0);
  }
  result = (int) ((arg1)->fc_idx);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_sourcedata_amp_arr_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "sourcedata-amp-arr-set"
  meep::sourcedata *arg1 = (meep::sourcedata *) 0 ;
  std::vector< std::complex< double > > arg2 ;
  std::vector< std::complex< double > > *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::sourcedata *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__sourcedata, 1, 0);
  }
  {
    argp2 = (std::vector< std::complex< double > > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__vectorT_std__complexT_double_t_t, 2, 0);
    arg2 = *argp2;
  }
  if (arg1) (arg1)->amp_arr = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_sourcedata_amp_arr_get (SCM s_0)
{
#define FUNC_NAME "sourcedata-amp-arr-get"
  meep::sourcedata *arg1 = (meep::sourcedata *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< std::complex< double > > result;
  
  {
    arg1 = (meep::sourcedata *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__sourcedata, 1, 0);
  }
  result =  ((arg1)->amp_arr);
  {
    std::vector< std::complex< double > > * resultptr;
    resultptr = new std::vector< std::complex< double > >((const std::vector< std::complex< double > > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_std__complexT_double_t_t, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_sourcedata ()
{
#define FUNC_NAME "new-sourcedata"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::sourcedata *result = 0 ;
  
  result = (meep::sourcedata *)new meep::sourcedata();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__sourcedata, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_sourcedata (SCM s_0)
{
#define FUNC_NAME "delete-sourcedata"
  meep::sourcedata *arg1 = (meep::sourcedata *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::sourcedata *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__sourcedata, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_near2far__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-near2far"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  double arg2 ;
  double arg3 ;
  int arg4 ;
  double arg5 ;
  double arg6 ;
  meep::volume *arg7 = 0 ;
  meep::direction *arg8 ;
  int *arg9 ;
  double *arg10 ;
  double *arg11 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_near2far *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__volume, 7, 0);
  }
  {
    arg8 = (meep::direction *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__direction, 8, 0);
  }
  {
    arg9 = (int *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_int, 9, 0);
  }
  {
    arg10 = (double *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_double, 10, 0);
  }
  {
    arg11 = (double *)SWIG_MustGetPtr(argv[10], SWIGTYPE_p_double, 11, 0);
  }
  result = (meep::dft_near2far *)new meep::dft_near2far(arg1,arg2,arg3,arg4,arg5,arg6,(meep::volume const &)*arg7,(meep::direction const (*))arg8,(int const (*))arg9,(double const (*))arg10,(double const (*))arg11);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_near2far, 1);
  }
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_near2far__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-near2far"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  std::vector< double > *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  meep::volume *arg5 = 0 ;
  meep::direction *arg6 ;
  int *arg7 ;
  double *arg8 ;
  double *arg9 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_near2far *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (std::vector< double > *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_std__vectorT_double_t, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (meep::volume *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__volume, 5, 0);
  }
  {
    arg6 = (meep::direction *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__direction, 6, 0);
  }
  {
    arg7 = (int *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_int, 7, 0);
  }
  {
    arg8 = (double *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_double, 8, 0);
  }
  {
    arg9 = (double *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_double, 9, 0);
  }
  result = (meep::dft_near2far *)new meep::dft_near2far(arg1,(std::vector< double > const &)*arg2,arg3,arg4,(meep::volume const &)*arg5,(meep::direction const (*))arg6,(int const (*))arg7,(double const (*))arg8,(double const (*))arg9);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_near2far, 1);
  }
  
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_near2far__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-near2far"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  double *arg2 = (double *) 0 ;
  size_t arg3 ;
  double arg4 ;
  double arg5 ;
  meep::volume *arg6 = 0 ;
  meep::direction *arg7 ;
  int *arg8 ;
  double *arg9 ;
  double *arg10 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_near2far *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (double *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_double, 2, 0);
  }
  {
    arg3 = (size_t) scm_to_ulong(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (meep::volume *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__volume, 6, 0);
  }
  {
    arg7 = (meep::direction *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__direction, 7, 0);
  }
  {
    arg8 = (int *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_int, 8, 0);
  }
  {
    arg9 = (double *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_double, 9, 0);
  }
  {
    arg10 = (double *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_double, 10, 0);
  }
  result = (meep::dft_near2far *)new meep::dft_near2far(arg1,(double const *)arg2,arg3,arg4,arg5,(meep::volume const &)*arg6,(meep::direction const (*))arg7,(int const (*))arg8,(double const (*))arg9,(double const (*))arg10);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_near2far, 1);
  }
  
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_near2far__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-near2far"
  meep::dft_near2far *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_near2far *result = 0 ;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  result = (meep::dft_near2far *)new meep::dft_near2far((meep::dft_near2far const &)*arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_near2far, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_near2far(SCM rest)
{
#define FUNC_NAME "new-meep-dft-near2far"
  SCM argv[11];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 11, "new-meep-dft-near2far");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_near2far, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_dft_near2far__SWIG_3(argc,argv);
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__direction, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_int, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_meep_dft_near2far__SWIG_1(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__direction, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_new_meep_dft_near2far__SWIG_2(argc,argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__direction, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_int, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, SWIGTYPE_p_double, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_new_meep_dft_near2far__SWIG_0(argc,argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-dft-near2far", "No matching method for generic function `new_meep_dft_near2far'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_farfield (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-near2far-farfield"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > *result = 0 ;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(s_1));
  arg2 = &vec__arg2;
  
  result = (std::complex< double > *)(arg1)->farfield((meep::vec const &)*arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_farfield_lowlevel (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-dft-near2far-farfield-lowlevel"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  std::complex< double > *arg2 = (std::complex< double > *) 0 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (std::complex< double > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__complexT_double_t, 2, 0);
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(s_2));
  arg3 = &vec__arg3;
  
  (arg1)->farfield_lowlevel(arg2,(meep::vec const &)*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_get_farfields_array (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5)
{
#define FUNC_NAME "meep-dft-near2far-get-farfields-array"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::volume *arg2 = 0 ;
  int *arg3 = 0 ;
  size_t *arg4 = (size_t *) 0 ;
  size_t *arg5 = 0 ;
  double arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double *result = 0 ;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (int *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_int, 3, 0);
  }
  {
    arg4 = (size_t *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_size_t, 4, 0);
  }
  {
    arg5 = (size_t *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_size_t, 5, 0);
  }
  {
    arg6 = (double) scm_to_double(s_5);
  }
  result = (double *)(arg1)->get_farfields_array((meep::volume const &)*arg2,*arg3,arg4,*arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_save_farfields (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4)
{
#define FUNC_NAME "meep-dft-near2far-save-farfields"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  meep::volume *arg4 = 0 ;
  double arg5 ;
  int must_free2 = 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  {
    arg3 = (char *)SWIG_scm2str(s_2);
    must_free3 = 1;
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__volume, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(s_4);
  }
  (arg1)->save_farfields((char const *)arg2,(char const *)arg3,(meep::volume const &)*arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  if (must_free3 && arg3) SWIG_free(arg3);
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_flux (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-dft-near2far-flux"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double *result = 0 ;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(s_3);
  }
  result = (double *)(arg1)->flux(arg2,(meep::volume const &)*arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_save_hdf5__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-near2far-save-hdf5"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->save_hdf5(arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_save_hdf5__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-near2far-save-hdf5"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  (arg1)->save_hdf5(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_load_hdf5__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-near2far-load-hdf5"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->load_hdf5(arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_load_hdf5__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-near2far-load-hdf5"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  (arg1)->load_hdf5(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_save_hdf5__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-near2far-save-hdf5"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  int must_free5 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  {
    arg5 = (char *)SWIG_scm2str(argv[4]);
    must_free5 = 1;
  }
  (arg1)->save_hdf5(*arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  if (must_free5 && arg5) SWIG_free(arg5);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_save_hdf5__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-near2far-save-hdf5"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  (arg1)->save_hdf5(*arg2,(char const *)arg3,(char const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_save_hdf5__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-near2far-save-hdf5"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->save_hdf5(*arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_save_hdf5(SCM rest)
{
#define FUNC_NAME "meep-dft-near2far-save-hdf5"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-dft-near2far-save-hdf5");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_near2far, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_dft_near2far_save_hdf5__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_near2far, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_near2far_save_hdf5__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_near2far, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_near2far_save_hdf5__SWIG_4(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_near2far, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_dft_near2far_save_hdf5__SWIG_3(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_near2far, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_string(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_dft_near2far_save_hdf5__SWIG_2(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-dft-near2far-save-hdf5", "No matching method for generic function `meep_dft_near2far_save_hdf5'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_load_hdf5__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-near2far-load-hdf5"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  int must_free5 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  {
    arg5 = (char *)SWIG_scm2str(argv[4]);
    must_free5 = 1;
  }
  (arg1)->load_hdf5(*arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  if (must_free5 && arg5) SWIG_free(arg5);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_load_hdf5__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-near2far-load-hdf5"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  int must_free3 = 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  (arg1)->load_hdf5(*arg2,(char const *)arg3,(char const *)arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_load_hdf5__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-dft-near2far-load-hdf5"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::fields *arg2 = 0 ;
  char *arg3 = (char *) 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->load_hdf5(*arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_load_hdf5(SCM rest)
{
#define FUNC_NAME "meep-dft-near2far-load-hdf5"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-dft-near2far-load-hdf5");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_near2far, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_dft_near2far_load_hdf5__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_near2far, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_near2far_load_hdf5__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_near2far, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_dft_near2far_load_hdf5__SWIG_4(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_near2far, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_dft_near2far_load_hdf5__SWIG_3(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_near2far, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_string(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_dft_near2far_load_hdf5__SWIG_2(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-dft-near2far-load-hdf5", "No matching method for generic function `meep_dft_near2far_load_hdf5'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_scale_dfts (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-near2far-scale-dfts"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->scale_dfts(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_remove (SCM s_0)
{
#define FUNC_NAME "meep-dft-near2far-remove"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  (arg1)->remove();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_freq_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-near2far-freq-set"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  std::vector< double > arg2 ;
  std::vector< double > *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    argp2 = (std::vector< double > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__vectorT_double_t, 2, 0);
    arg2 = *argp2;
  }
  if (arg1) (arg1)->freq = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_freq_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-near2far-freq-get"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< double > result;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  result =  ((arg1)->freq);
  {
    std::vector< double > * resultptr;
    resultptr = new std::vector< double >((const std::vector< double > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_double_t, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_F_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-near2far-F-set"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  if (arg1) (arg1)->F = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_F_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-near2far-F-get"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  result = (meep::dft_chunk *) ((arg1)->F);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_eps_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-near2far-eps-set"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->eps = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_eps_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-near2far-eps-get"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  result = (double) ((arg1)->eps);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_mu_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-near2far-mu-set"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->mu = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_mu_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-near2far-mu-get"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  result = (double) ((arg1)->mu);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_where_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-near2far-where-set"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::volume *arg2 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  if (arg1) (arg1)->where = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_where_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-near2far-where-get"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume *result = 0 ;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  result = (meep::volume *)& ((arg1)->where);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_periodic_d_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-near2far-periodic-d-set"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::direction *arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::direction *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__direction, 2, 0);
  }
  {
    size_t ii;
    meep::direction *b = (meep::direction *) arg1->periodic_d;
    for (ii = 0; ii < (size_t)2; ii++) b[ii] = *((meep::direction *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_periodic_d_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-near2far-periodic-d-get"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::direction *result = 0 ;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  result = (meep::direction *)(meep::direction *) ((arg1)->periodic_d);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__direction, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_periodic_n_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-near2far-periodic-n-set"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  int *arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (int *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_int, 2, 0);
  }
  {
    size_t ii;
    int *b = (int *) arg1->periodic_n;
    for (ii = 0; ii < (size_t)2; ii++) b[ii] = *((int *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_periodic_n_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-near2far-periodic-n-get"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int *result = 0 ;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  result = (int *)(int *) ((arg1)->periodic_n);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_int, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_periodic_k_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-near2far-periodic-k-set"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  double *arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (double *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_double, 2, 0);
  }
  {
    size_t ii;
    double *b = (double *) arg1->periodic_k;
    for (ii = 0; ii < (size_t)2; ii++) b[ii] = *((double *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_periodic_k_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-near2far-periodic-k-get"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double *result = 0 ;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  result = (double *)(double *) ((arg1)->periodic_k);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_period_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-near2far-period-set"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  double *arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (double *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_double, 2, 0);
  }
  {
    size_t ii;
    double *b = (double *) arg1->period;
    for (ii = 0; ii < (size_t)2; ii++) b[ii] = *((double *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_period_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-near2far-period-get"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double *result = 0 ;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  result = (double *)(double *) ((arg1)->period);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_near2far_near_sourcedata (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4)
{
#define FUNC_NAME "meep-dft-near2far-near-sourcedata"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::vec *arg2 = 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  std::complex< double > *arg5 = (std::complex< double > *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< std::vector< meep::sourcedata > > result;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(s_1));
  arg2 = &vec__arg2;
  
  {
    arg3 = (double *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (size_t) scm_to_ulong(s_3);
  }
  {
    arg5 = (std::complex< double > *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_std__complexT_double_t, 5, 0);
  }
  result = (arg1)->near_sourcedata((meep::vec const &)*arg2,arg3,arg4,(std::complex< double > const *)arg5);
  {
    std::vector< meep::sourcedata > * resultptr;
    resultptr = new std::vector< meep::sourcedata >((const std::vector< meep::sourcedata > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_meep__sourcedata_t, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_dft_near2far (SCM s_0)
{
#define FUNC_NAME "delete-meep-dft-near2far"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_ldos__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-ldos"
  double arg1 ;
  double arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_ldos *result = 0 ;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  result = (meep::dft_ldos *)new meep::dft_ldos(arg1,arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_ldos, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_ldos__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-ldos"
  std::vector< double > arg1 ;
  std::vector< double > *argp1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_ldos *result = 0 ;
  
  {
    argp1 = (std::vector< double > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__vectorT_double_t, 1, 0);
    arg1 = *argp1;
  }
  result = (meep::dft_ldos *)new meep::dft_ldos(arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_ldos, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_ldos__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-ldos"
  double *arg1 = (double *) 0 ;
  size_t arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_ldos *result = 0 ;
  
  {
    arg1 = (double *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_double, 1, 0);
  }
  {
    arg2 = (size_t) scm_to_ulong(argv[1]);
  }
  result = (meep::dft_ldos *)new meep::dft_ldos((double const *)arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_ldos, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_ldos(SCM rest)
{
#define FUNC_NAME "new-meep-dft-ldos"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "new-meep-dft-ldos");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_dft_ldos__SWIG_1(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_double, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_new_meep_dft_ldos__SWIG_2(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_new_meep_dft_ldos__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("new-meep-dft-ldos", "No matching method for generic function `new_meep_dft_ldos'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_dft_ldos (SCM s_0)
{
#define FUNC_NAME "delete-meep-dft-ldos"
  meep::dft_ldos *arg1 = (meep::dft_ldos *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_ldos *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_ldos, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_ldos_update (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-ldos-update"
  meep::dft_ldos *arg1 = (meep::dft_ldos *) 0 ;
  meep::fields *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_ldos *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_ldos, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__fields, 2, 0);
  }
  (arg1)->update(*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_ldos_ldos (SCM s_0)
{
#define FUNC_NAME "meep-dft-ldos-ldos"
  meep::dft_ldos *arg1 = (meep::dft_ldos *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double *result = 0 ;
  
  {
    arg1 = (meep::dft_ldos *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_ldos, 1, 0);
  }
  result = (double *)(arg1)->ldos();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_ldos_F (SCM s_0)
{
#define FUNC_NAME "meep-dft-ldos-F"
  meep::dft_ldos *arg1 = (meep::dft_ldos *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > *result = 0 ;
  
  {
    arg1 = (meep::dft_ldos *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_ldos, 1, 0);
  }
  result = (std::complex< double > *)((meep::dft_ldos const *)arg1)->F();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_ldos_J (SCM s_0)
{
#define FUNC_NAME "meep-dft-ldos-J"
  meep::dft_ldos *arg1 = (meep::dft_ldos *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > *result = 0 ;
  
  {
    arg1 = (meep::dft_ldos *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_ldos, 1, 0);
  }
  result = (std::complex< double > *)((meep::dft_ldos const *)arg1)->J();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_ldos_freq_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-ldos-freq-set"
  meep::dft_ldos *arg1 = (meep::dft_ldos *) 0 ;
  std::vector< double > arg2 ;
  std::vector< double > *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_ldos *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_ldos, 1, 0);
  }
  {
    argp2 = (std::vector< double > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__vectorT_double_t, 2, 0);
    arg2 = *argp2;
  }
  if (arg1) (arg1)->freq = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_ldos_freq_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-ldos-freq-get"
  meep::dft_ldos *arg1 = (meep::dft_ldos *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< double > result;
  
  {
    arg1 = (meep::dft_ldos *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_ldos, 1, 0);
  }
  result =  ((arg1)->freq);
  {
    std::vector< double > * resultptr;
    resultptr = new std::vector< double >((const std::vector< double > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_double_t, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_ldos_overall_scale (SCM s_0)
{
#define FUNC_NAME "meep-dft-ldos-overall-scale"
  meep::dft_ldos *arg1 = (meep::dft_ldos *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::dft_ldos *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_ldos, 1, 0);
  }
  result = (double)((meep::dft_ldos const *)arg1)->overall_scale();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_fields__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-fields"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  double arg2 ;
  double arg3 ;
  int arg4 ;
  meep::volume *arg5 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_fields *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (meep::volume *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__volume, 5, 0);
  }
  result = (meep::dft_fields *)new meep::dft_fields(arg1,arg2,arg3,arg4,(meep::volume const &)*arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_fields__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-fields"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  std::vector< double > *arg2 = 0 ;
  meep::volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_fields *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (std::vector< double > *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_std__vectorT_double_t, 2, 0);
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  result = (meep::dft_fields *)new meep::dft_fields(arg1,(std::vector< double > const &)*arg2,(meep::volume const &)*arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_fields__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-dft-fields"
  meep::dft_chunk *arg1 = (meep::dft_chunk *) 0 ;
  double *arg2 = (double *) 0 ;
  size_t arg3 ;
  meep::volume *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_fields *result = 0 ;
  
  {
    arg1 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__dft_chunk, 1, 0);
  }
  {
    arg2 = (double *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_double, 2, 0);
  }
  {
    arg3 = (size_t) scm_to_ulong(argv[2]);
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
  }
  result = (meep::dft_fields *)new meep::dft_fields(arg1,(double const *)arg2,arg3,(meep::volume const &)*arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_dft_fields(SCM rest)
{
#define FUNC_NAME "new-meep-dft-fields"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "new-meep-dft-fields");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_meep_dft_fields__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_meep_dft_fields__SWIG_2(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_meep_dft_fields__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-dft-fields", "No matching method for generic function `new_meep_dft_fields'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_fields_fourier_sourcedata (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4)
{
#define FUNC_NAME "meep-dft-fields-fourier-sourcedata"
  meep::dft_fields *arg1 = (meep::dft_fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::component arg3 ;
  meep::fields *arg4 = 0 ;
  std::complex< double > *arg5 = (std::complex< double > *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< std::vector< meep::sourcedata > > result;
  
  {
    arg1 = (meep::dft_fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::component) scm_to_int(s_2); 
  }
  {
    arg4 = (meep::fields *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__fields, 4, 0);
  }
  {
    arg5 = (std::complex< double > *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_std__complexT_double_t, 5, 0);
  }
  result = (arg1)->fourier_sourcedata((meep::volume const &)*arg2,arg3,*arg4,(std::complex< double > const *)arg5);
  {
    std::vector< meep::sourcedata > * resultptr;
    resultptr = new std::vector< meep::sourcedata >((const std::vector< meep::sourcedata > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_meep__sourcedata_t, 1);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_fields_scale_dfts (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-fields-scale-dfts"
  meep::dft_fields *arg1 = (meep::dft_fields *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_fields, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->scale_dfts(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_fields_remove (SCM s_0)
{
#define FUNC_NAME "meep-dft-fields-remove"
  meep::dft_fields *arg1 = (meep::dft_fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_fields, 1, 0);
  }
  (arg1)->remove();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_fields_freq_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-fields-freq-set"
  meep::dft_fields *arg1 = (meep::dft_fields *) 0 ;
  std::vector< double > arg2 ;
  std::vector< double > *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_fields, 1, 0);
  }
  {
    argp2 = (std::vector< double > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__vectorT_double_t, 2, 0);
    arg2 = *argp2;
  }
  if (arg1) (arg1)->freq = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_fields_freq_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-fields-freq-get"
  meep::dft_fields *arg1 = (meep::dft_fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< double > result;
  
  {
    arg1 = (meep::dft_fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_fields, 1, 0);
  }
  result =  ((arg1)->freq);
  {
    std::vector< double > * resultptr;
    resultptr = new std::vector< double >((const std::vector< double > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_double_t, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_fields_chunks_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-fields-chunks-set"
  meep::dft_fields *arg1 = (meep::dft_fields *) 0 ;
  meep::dft_chunk *arg2 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_chunk, 2, 0);
  }
  if (arg1) (arg1)->chunks = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_fields_chunks_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-fields-chunks-get"
  meep::dft_fields *arg1 = (meep::dft_fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::dft_fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_fields, 1, 0);
  }
  result = (meep::dft_chunk *) ((arg1)->chunks);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_fields_where_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-dft-fields-where-set"
  meep::dft_fields *arg1 = (meep::dft_fields *) 0 ;
  meep::volume *arg2 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  if (arg1) (arg1)->where = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_dft_fields_where_get (SCM s_0)
{
#define FUNC_NAME "meep-dft-fields-where-get"
  meep::dft_fields *arg1 = (meep::dft_fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume *result = 0 ;
  
  {
    arg1 = (meep::dft_fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_fields, 1, 0);
  }
  result = (meep::volume *)& ((arg1)->where);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_dft_fields (SCM s_0)
{
#define FUNC_NAME "delete-meep-dft-fields"
  meep::dft_fields *arg1 = (meep::dft_fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::dft_fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_fields, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_polarization_state_data_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "polarization-state-data-set"
  meep::polarization_state_s *arg1 = (meep::polarization_state_s *) 0 ;
  void *arg2 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::polarization_state_s *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__polarization_state_s, 1, 0);
  }
  {
    arg2 = (void *)SWIG_MustGetPtr(s_1, NULL, 2, 0);
  }
  if (arg1) (arg1)->data = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_polarization_state_data_get (SCM s_0)
{
#define FUNC_NAME "polarization-state-data-get"
  meep::polarization_state_s *arg1 = (meep::polarization_state_s *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::polarization_state_s *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__polarization_state_s, 1, 0);
  }
  result = (void *) ((arg1)->data);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_polarization_state_s_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "polarization-state-s-set"
  meep::polarization_state_s *arg1 = (meep::polarization_state_s *) 0 ;
  meep::susceptibility *arg2 = (meep::susceptibility *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::polarization_state_s *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__polarization_state_s, 1, 0);
  }
  {
    arg2 = (meep::susceptibility *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__susceptibility, 2, 0);
  }
  if (arg1) (arg1)->s = (meep::susceptibility const *)arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_polarization_state_s_get (SCM s_0)
{
#define FUNC_NAME "polarization-state-s-get"
  meep::polarization_state_s *arg1 = (meep::polarization_state_s *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::susceptibility *result = 0 ;
  
  {
    arg1 = (meep::polarization_state_s *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__polarization_state_s, 1, 0);
  }
  result = (meep::susceptibility *) ((arg1)->s);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__susceptibility, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_polarization_state_next_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "polarization-state-next-set"
  meep::polarization_state_s *arg1 = (meep::polarization_state_s *) 0 ;
  meep::polarization_state_s *arg2 = (meep::polarization_state_s *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::polarization_state_s *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__polarization_state_s, 1, 0);
  }
  {
    arg2 = (meep::polarization_state_s *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__polarization_state_s, 2, 0);
  }
  if (arg1) (arg1)->next = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_polarization_state_next_get (SCM s_0)
{
#define FUNC_NAME "polarization-state-next-get"
  meep::polarization_state_s *arg1 = (meep::polarization_state_s *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::polarization_state_s *result = 0 ;
  
  {
    arg1 = (meep::polarization_state_s *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__polarization_state_s, 1, 0);
  }
  result = (meep::polarization_state_s *) ((arg1)->next);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__polarization_state_s, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_polarization_state ()
{
#define FUNC_NAME "new-polarization-state"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::polarization_state_s *result = 0 ;
  
  result = (meep::polarization_state_s *)new meep::polarization_state_s();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__polarization_state_s, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_polarization_state (SCM s_0)
{
#define FUNC_NAME "delete-polarization-state"
  meep::polarization_state_s *arg1 = (meep::polarization_state_s *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::polarization_state_s *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__polarization_state_s, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_boundary_condition_Periodic(SCM s_0)
{
#define FUNC_NAME "meep-boundary-condition-Periodic"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_boundary_condition_Periodic);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_boundary_condition_Metallic(SCM s_0)
{
#define FUNC_NAME "meep-boundary-condition-Metallic"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_boundary_condition_Metallic);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_boundary_condition_Magnetic(SCM s_0)
{
#define FUNC_NAME "meep-boundary-condition-Magnetic"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_boundary_condition_Magnetic);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_boundary_condition_None(SCM s_0)
{
#define FUNC_NAME "meep-boundary-condition-None"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_boundary_condition_None);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_Connecting(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-Connecting"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_Connecting);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_Stepping(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-Stepping"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_Stepping);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_Boundaries(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-Boundaries"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_Boundaries);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_MpiAllTime(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-MpiAllTime"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_MpiAllTime);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_MpiOneTime(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-MpiOneTime"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_MpiOneTime);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_FieldOutput(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-FieldOutput"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_FieldOutput);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_FourierTransforming(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-FourierTransforming"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_FourierTransforming);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_MPBTime(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-MPBTime"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_MPBTime);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_GetFarfieldsTime(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-GetFarfieldsTime"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_GetFarfieldsTime);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_Other(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-Other"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_Other);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_FieldUpdateB(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-FieldUpdateB"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_FieldUpdateB);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_FieldUpdateH(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-FieldUpdateH"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_FieldUpdateH);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_FieldUpdateD(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-FieldUpdateD"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_FieldUpdateD);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_FieldUpdateE(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-FieldUpdateE"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_FieldUpdateE);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_BoundarySteppingB(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-BoundarySteppingB"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_BoundarySteppingB);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_BoundarySteppingWH(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-BoundarySteppingWH"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_BoundarySteppingWH);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_BoundarySteppingPH(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-BoundarySteppingPH"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_BoundarySteppingPH);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_BoundarySteppingH(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-BoundarySteppingH"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_BoundarySteppingH);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_BoundarySteppingD(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-BoundarySteppingD"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_BoundarySteppingD);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_BoundarySteppingWE(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-BoundarySteppingWE"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_BoundarySteppingWE);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_BoundarySteppingPE(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-BoundarySteppingPE"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_BoundarySteppingPE);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_time_sink_BoundarySteppingE(SCM s_0)
{
#define FUNC_NAME "meep-time-sink-BoundarySteppingE"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_meep_time_sink_BoundarySteppingE);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_timing_scope__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-timing-scope"
  meep::time_sink_to_duration_map *arg1 = (meep::time_sink_to_duration_map *) 0 ;
  meep::time_sink arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::timing_scope *result = 0 ;
  
  {
    arg1 = (meep::time_sink_to_duration_map *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__unordered_mapT_meep__time_sink_double_std__hashT_int_t_t, 1, 0);
  }
  {
    arg2 = (meep::time_sink) scm_to_int(argv[1]); 
  }
  result = (meep::timing_scope *)new meep::timing_scope(arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__timing_scope, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_timing_scope__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-timing-scope"
  meep::time_sink_to_duration_map *arg1 = (meep::time_sink_to_duration_map *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::timing_scope *result = 0 ;
  
  {
    arg1 = (meep::time_sink_to_duration_map *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__unordered_mapT_meep__time_sink_double_std__hashT_int_t_t, 1, 0);
  }
  result = (meep::timing_scope *)new meep::timing_scope(arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__timing_scope, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_timing_scope(SCM rest)
{
#define FUNC_NAME "new-timing-scope"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "new-timing-scope");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__unordered_mapT_meep__time_sink_double_std__hashT_int_t_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_timing_scope__SWIG_1(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__unordered_mapT_meep__time_sink_double_std__hashT_int_t_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_new_timing_scope__SWIG_0(argc,argv);
      }
    }
  }
  
  scm_misc_error("new-timing-scope", "No matching method for generic function `new_timing_scope'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_delete_timing_scope (SCM s_0)
{
#define FUNC_NAME "delete-timing-scope"
  meep::timing_scope *arg1 = (meep::timing_scope *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::timing_scope *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__timing_scope, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_timing_scope_exit (SCM s_0)
{
#define FUNC_NAME "timing-scope-exit"
  meep::timing_scope *arg1 = (meep::timing_scope *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::timing_scope *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__timing_scope, 1, 0);
  }
  (arg1)->exit();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_derived_component_func (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-derived-component-func"
  meep::derived_component arg1 ;
  meep::grid_volume *arg2 = 0 ;
  int *arg3 = 0 ;
  meep::component *arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::field_rfunction result;
  
  {
    arg1 = (meep::derived_component) scm_to_int(s_0); 
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  {
    arg3 = (int *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_int, 3, 0);
  }
  {
    arg4 = (meep::component *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__component, 4, 0);
  }
  result = (meep::field_rfunction)meep::derived_component_func(arg1,(meep::grid_volume const &)*arg2,*arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_chunkloop_field_components (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5, SCM s_6)
{
#define FUNC_NAME "new-meep-chunkloop-field-components"
  meep::fields_chunk *arg1 = (meep::fields_chunk *) 0 ;
  meep::component arg2 ;
  std::complex< double > arg3 ;
  meep::symmetry *arg4 = 0 ;
  int arg5 ;
  int arg6 ;
  meep::component *arg7 = (meep::component *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::chunkloop_field_components *result = 0 ;
  
  {
    arg1 = (meep::fields_chunk *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields_chunk, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_2);
    arg3 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg4 = (meep::symmetry *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__symmetry, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(s_4);
  }
  {
    arg6 = (int) scm_to_int(s_5);
  }
  {
    arg7 = (meep::component *)SWIG_MustGetPtr(s_6, SWIGTYPE_p_meep__component, 7, 0);
  }
  result = (meep::chunkloop_field_components *)new meep::chunkloop_field_components(arg1,arg2,arg3,(meep::symmetry const &)*arg4,arg5,arg6,(meep::component const *)arg7);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__chunkloop_field_components, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_chunkloop_field_components_update_values (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-chunkloop-field-components-update-values"
  meep::chunkloop_field_components *arg1 = (meep::chunkloop_field_components *) 0 ;
  ptrdiff_t arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::chunkloop_field_components *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__chunkloop_field_components, 1, 0);
  }
  {
    arg2 = (ptrdiff_t) scm_to_long(s_1);
  }
  (arg1)->update_values(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_chunkloop_field_components_values_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-chunkloop-field-components-values-set"
  meep::chunkloop_field_components *arg1 = (meep::chunkloop_field_components *) 0 ;
  std::vector< std::complex< double > > arg2 ;
  std::vector< std::complex< double > > *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::chunkloop_field_components *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__chunkloop_field_components, 1, 0);
  }
  {
    argp2 = (std::vector< std::complex< double > > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__vectorT_std__complexT_double_t_t, 2, 0);
    arg2 = *argp2;
  }
  if (arg1) (arg1)->values = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_chunkloop_field_components_values_get (SCM s_0)
{
#define FUNC_NAME "meep-chunkloop-field-components-values-get"
  meep::chunkloop_field_components *arg1 = (meep::chunkloop_field_components *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< std::complex< double > > result;
  
  {
    arg1 = (meep::chunkloop_field_components *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__chunkloop_field_components, 1, 0);
  }
  result =  ((arg1)->values);
  {
    std::vector< std::complex< double > > * resultptr;
    resultptr = new std::vector< std::complex< double > >((const std::vector< std::complex< double > > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_std__complexT_double_t_t, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_chunkloop_field_components (SCM s_0)
{
#define FUNC_NAME "delete-meep-chunkloop-field-components"
  meep::chunkloop_field_components *arg1 = (meep::chunkloop_field_components *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::chunkloop_field_components *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__chunkloop_field_components, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_diffractedplanewave (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "new-meep-diffractedplanewave"
  int *arg1 ;
  double *arg2 ;
  std::complex< double > arg3 ;
  std::complex< double > arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::diffractedplanewave *result = 0 ;
  
  {
    arg1 = (int *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_int, 1, 0);
  }
  {
    arg2 = (double *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_double, 2, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_2);
    arg3 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_3);
    arg4 = std::complex<double>(cnum.re, cnum.im);
  }
  result = (meep::diffractedplanewave *)new meep::diffractedplanewave(arg1,arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__diffractedplanewave, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_diffractedplanewave_get_g (SCM s_0)
{
#define FUNC_NAME "meep-diffractedplanewave-get-g"
  meep::diffractedplanewave *arg1 = (meep::diffractedplanewave *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int *result = 0 ;
  
  {
    arg1 = (meep::diffractedplanewave *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__diffractedplanewave, 1, 0);
  }
  result = (int *)(arg1)->get_g();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_int, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_diffractedplanewave_get_axis (SCM s_0)
{
#define FUNC_NAME "meep-diffractedplanewave-get-axis"
  meep::diffractedplanewave *arg1 = (meep::diffractedplanewave *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double *result = 0 ;
  
  {
    arg1 = (meep::diffractedplanewave *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__diffractedplanewave, 1, 0);
  }
  result = (double *)(arg1)->get_axis();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_diffractedplanewave_get_s (SCM s_0)
{
#define FUNC_NAME "meep-diffractedplanewave-get-s"
  meep::diffractedplanewave *arg1 = (meep::diffractedplanewave *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::diffractedplanewave *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__diffractedplanewave, 1, 0);
  }
  result = ((meep::diffractedplanewave const *)arg1)->get_s();
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_diffractedplanewave_get_p (SCM s_0)
{
#define FUNC_NAME "meep-diffractedplanewave-get-p"
  meep::diffractedplanewave *arg1 = (meep::diffractedplanewave *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::diffractedplanewave *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__diffractedplanewave, 1, 0);
  }
  result = ((meep::diffractedplanewave const *)arg1)->get_p();
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_diffractedplanewave (SCM s_0)
{
#define FUNC_NAME "delete-meep-diffractedplanewave"
  meep::diffractedplanewave *arg1 = (meep::diffractedplanewave *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::diffractedplanewave *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__diffractedplanewave, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_gaussianbeam (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5, SCM s_6)
{
#define FUNC_NAME "new-meep-gaussianbeam"
  meep::vec *arg1 = 0 ;
  meep::vec *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  std::complex< double > *arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::gaussianbeam *result = 0 ;
  
  
  meep::vec vec__arg1 = vector3_to_vec(ctl_convert_vector3_to_c(s_0));
  arg1 = &vec__arg1;
  
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(s_1));
  arg2 = &vec__arg2;
  
  {
    arg3 = (double) scm_to_double(s_2);
  }
  {
    arg4 = (double) scm_to_double(s_3);
  }
  {
    arg5 = (double) scm_to_double(s_4);
  }
  {
    arg6 = (double) scm_to_double(s_5);
  }
  {
    arg7 = (std::complex< double > *)SWIG_MustGetPtr(s_6, SWIGTYPE_p_std__complexT_double_t, 7, 0);
  }
  result = (meep::gaussianbeam *)new meep::gaussianbeam((meep::vec const &)*arg1,(meep::vec const &)*arg2,arg3,arg4,arg5,arg6,arg7);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__gaussianbeam, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gaussianbeam_get_fields (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-gaussianbeam-get-fields"
  meep::gaussianbeam *arg1 = (meep::gaussianbeam *) 0 ;
  std::complex< double > *arg2 = (std::complex< double > *) 0 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::gaussianbeam *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gaussianbeam, 1, 0);
  }
  {
    arg2 = (std::complex< double > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__complexT_double_t, 2, 0);
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(s_2));
  arg3 = &vec__arg3;
  
  ((meep::gaussianbeam const *)arg1)->get_fields(arg2,(meep::vec const &)*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gaussianbeam_get_E0 (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-gaussianbeam-get-E0"
  meep::gaussianbeam *arg1 = (meep::gaussianbeam *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::gaussianbeam *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gaussianbeam, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  result = ((meep::gaussianbeam const *)arg1)->get_E0(arg2);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_gaussianbeam (SCM s_0)
{
#define FUNC_NAME "delete-meep-gaussianbeam"
  meep::gaussianbeam *arg1 = (meep::gaussianbeam *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::gaussianbeam *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__gaussianbeam, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_num_chunks_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-num-chunks-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  if (arg1) (arg1)->num_chunks = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_num_chunks_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-num-chunks-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (int) ((arg1)->num_chunks);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_shared_chunks_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-shared-chunks-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  bool arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (bool) scm_is_true(s_1);
  }
  if (arg1) (arg1)->shared_chunks = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_shared_chunks_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-shared-chunks-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (bool) ((arg1)->shared_chunks);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_chunks_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-chunks-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::fields_chunk **arg2 = (meep::fields_chunk **) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::fields_chunk **)SWIG_MustGetPtr(s_1, SWIGTYPE_p_p_meep__fields_chunk, 2, 0);
  }
  if (arg1) (arg1)->chunks = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_chunks_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-chunks-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::fields_chunk **result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (meep::fields_chunk **) ((arg1)->chunks);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_p_meep__fields_chunk, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_sources_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-sources-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::src_time *arg2 = (meep::src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::src_time *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__src_time, 2, 0);
  }
  if (arg1) (arg1)->sources = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_sources_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-sources-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::src_time *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (meep::src_time *) ((arg1)->sources);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__src_time, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_fluxes_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-fluxes-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::flux_vol *arg2 = (meep::flux_vol *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::flux_vol *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__flux_vol, 2, 0);
  }
  if (arg1) (arg1)->fluxes = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_fluxes_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-fluxes-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::flux_vol *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (meep::flux_vol *) ((arg1)->fluxes);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__flux_vol, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_S_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-S-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::symmetry *arg2 = (meep::symmetry *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::symmetry *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__symmetry, 2, 0);
  }
  if (arg1) (arg1)->S = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_S_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-S-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::symmetry *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (meep::symmetry *)& ((arg1)->S);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__symmetry, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_a_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-a-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->a = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_a_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-a-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double) ((arg1)->a);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_dt_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-dt-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->dt = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_dt_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-dt-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double) ((arg1)->dt);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_gv_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-gv-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::grid_volume *arg2 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  if (arg1) (arg1)->gv = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_gv_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-gv-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (meep::grid_volume *)& ((arg1)->gv);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__grid_volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_user_volume_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-user-volume-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::grid_volume *arg2 = (meep::grid_volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::grid_volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__grid_volume, 2, 0);
  }
  if (arg1) (arg1)->user_volume = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_user_volume_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-user-volume-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::grid_volume *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (meep::grid_volume *)& ((arg1)->user_volume);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__grid_volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_v_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-v-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = (meep::volume *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  if (arg1) (arg1)->v = *arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_v_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-v-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (meep::volume *)& ((arg1)->v);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_m_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-m-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->m = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_m_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-m-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double) ((arg1)->m);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_beta_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-beta-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->beta = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_beta_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-beta-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double) ((arg1)->beta);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_t_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-t-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  if (arg1) (arg1)->t = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_t_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-t-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (int) ((arg1)->t);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_phasein_time_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-phasein-time-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  if (arg1) (arg1)->phasein_time = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_phasein_time_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-phasein-time-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (int) ((arg1)->phasein_time);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_is_real_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-is-real-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  if (arg1) (arg1)->is_real = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_is_real_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-is-real-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (int) ((arg1)->is_real);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_k_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-k-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  std::complex< double > *arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (std::complex< double > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__complexT_double_t, 2, 0);
  }
  {
    size_t ii;
    std::complex< double > *b = (std::complex< double > *) arg1->k;
    for (ii = 0; ii < (size_t)5; ii++) b[ii] = *((std::complex< double > *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_k_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-k-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (std::complex< double > *)(std::complex< double > *) ((arg1)->k);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_eikna_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-eikna-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  std::complex< double > *arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (std::complex< double > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__complexT_double_t, 2, 0);
  }
  {
    size_t ii;
    std::complex< double > *b = (std::complex< double > *) arg1->eikna;
    for (ii = 0; ii < (size_t)5; ii++) b[ii] = *((std::complex< double > *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_eikna_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-eikna-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (std::complex< double > *)(std::complex< double > *) ((arg1)->eikna);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_coskna_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-coskna-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double *arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_double, 2, 0);
  }
  {
    size_t ii;
    double *b = (double *) arg1->coskna;
    for (ii = 0; ii < (size_t)5; ii++) b[ii] = *((double *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_coskna_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-coskna-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double *)(double *) ((arg1)->coskna);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_sinkna_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-sinkna-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double *arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_double, 2, 0);
  }
  {
    size_t ii;
    double *b = (double *) arg1->sinkna;
    for (ii = 0; ii < (size_t)5; ii++) b[ii] = *((double *) arg2 + ii);
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_sinkna_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-sinkna-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double *)(double *) ((arg1)->sinkna);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_boundaries_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-boundaries-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::boundary_condition (*arg2)[5] ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::boundary_condition (*)[5])SWIG_MustGetPtr(s_1, SWIGTYPE_p_a_5__meep__boundary_condition, 2, 0);
  }
  {
    meep::boundary_condition (*inp)[5] = (meep::boundary_condition (*)[5])(arg2);
    meep::boundary_condition (*dest)[5] = (meep::boundary_condition (*)[5])(arg1->boundaries);
    size_t ii = 0;
    for (; ii < 2; ++ii) {
      meep::boundary_condition *ip = inp[ii];
      meep::boundary_condition *dp = dest[ii];
      size_t jj = 0;
      for (; jj < 5; ++jj) dp[jj] = ip[jj];
    }
  }
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_boundaries_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-boundaries-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::boundary_condition (*result)[5] = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (meep::boundary_condition (*)[5])(meep::boundary_condition (*)[5]) ((arg1)->boundaries);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_a_5__meep__boundary_condition, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_outdir_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-outdir-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  {
    delete [] arg1->outdir;
    if (arg2) {
      arg1->outdir = (char *) (new char[strlen((const char *)arg2)+1]);
      strcpy((char *)arg1->outdir, (const char *)arg2);
    } else {
      arg1->outdir = 0;
    }
  }
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_outdir_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-outdir-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (char *) ((arg1)->outdir);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_components_allocated_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-components-allocated-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  bool arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (bool) scm_is_true(s_1);
  }
  if (arg1) (arg1)->components_allocated = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_components_allocated_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-components-allocated-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (bool) ((arg1)->components_allocated);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_loop_tile_base_db_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-loop-tile-base-db-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  size_t arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (size_t) scm_to_ulong(s_1);
  }
  if (arg1) (arg1)->loop_tile_base_db = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_loop_tile_base_db_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-loop-tile-base-db-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  size_t result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result =  ((arg1)->loop_tile_base_db);
  {
    gswig_result = scm_from_ulong(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_loop_tile_base_eh_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-loop-tile-base-eh-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  size_t arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (size_t) scm_to_ulong(s_1);
  }
  if (arg1) (arg1)->loop_tile_base_eh = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_loop_tile_base_eh_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-loop-tile-base-eh-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  size_t result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result =  ((arg1)->loop_tile_base_eh);
  {
    gswig_result = scm_from_ulong(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_fields__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-fields"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  int arg5 ;
  int arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::fields *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  result = (meep::fields *)new meep::fields(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__fields, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_fields__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-fields"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::fields *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (meep::fields *)new meep::fields(arg1,arg2,arg3,arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__fields, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_fields__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-fields"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double arg2 ;
  double arg3 ;
  bool arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::fields *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  result = (meep::fields *)new meep::fields(arg1,arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__fields, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_fields__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-fields"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::fields *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  result = (meep::fields *)new meep::fields(arg1,arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__fields, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_fields__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-fields"
  meep::structure *arg1 = (meep::structure *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::fields *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  result = (meep::fields *)new meep::fields(arg1,arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__fields, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_fields__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-fields"
  meep::structure *arg1 = (meep::structure *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::fields *result = 0 ;
  
  {
    arg1 = (meep::structure *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__structure, 1, 0);
  }
  result = (meep::fields *)new meep::fields(arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__fields, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_fields__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-fields"
  meep::fields *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::fields *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (meep::fields *)new meep::fields((meep::fields const &)*arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__fields, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_fields(SCM rest)
{
#define FUNC_NAME "new-meep-fields"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "new-meep-fields");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_fields__SWIG_5(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_fields__SWIG_6(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_new_meep_fields__SWIG_4(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_new_meep_fields__SWIG_3(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_new_meep_fields__SWIG_2(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_new_meep_fields__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__structure, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                return _wrap_new_meep_fields__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("new-meep-fields", "No matching method for generic function `new_meep_fields'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_fields (SCM s_0)
{
#define FUNC_NAME "delete-meep-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_equal_layout (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-equal-layout"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::fields *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__fields, 2, 0);
  }
  result = (bool)((meep::fields const *)arg1)->equal_layout((meep::fields const &)*arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_use_real_fields (SCM s_0)
{
#define FUNC_NAME "meep-fields-use-real-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->use_real_fields();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_zero_fields (SCM s_0)
{
#define FUNC_NAME "meep-fields-zero-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->zero_fields();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_remove_sources (SCM s_0)
{
#define FUNC_NAME "meep-fields-remove-sources"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->remove_sources();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_remove_susceptibilities (SCM s_0)
{
#define FUNC_NAME "meep-fields-remove-susceptibilities"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->remove_susceptibilities();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_remove_fluxes (SCM s_0)
{
#define FUNC_NAME "meep-fields-remove-fluxes"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->remove_fluxes();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_reset (SCM s_0)
{
#define FUNC_NAME "meep-fields-reset"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->reset();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_log__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-log"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  (arg1)->log((char const *)arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_log__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-log"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->log();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_log(SCM rest)
{
#define FUNC_NAME "meep-fields-log"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-fields-log");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_fields_log__SWIG_1(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_fields_log__SWIG_0(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-fields-log", "No matching method for generic function `meep_fields_log'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_change_m (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-change-m"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  (arg1)->change_m(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_time_spent_on (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-time-spent-on"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::time_sink arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::time_sink) scm_to_int(s_1); 
  }
  result = (arg1)->time_spent_on(arg2);
  {
    std::vector< double > * resultptr;
    resultptr = new std::vector< double >((const std::vector< double > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_double_t, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_mean_time_spent_on (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-mean-time-spent-on"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::time_sink arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::time_sink) scm_to_int(s_1); 
  }
  result = (double)(arg1)->mean_time_spent_on(arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_print_times (SCM s_0)
{
#define FUNC_NAME "meep-fields-print-times"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->print_times();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_set_boundary (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-fields-set-boundary"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::boundary_side arg2 ;
  meep::direction arg3 ;
  meep::boundary_condition arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::boundary_side) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::direction) scm_to_int(s_2); 
  }
  {
    arg4 = (meep::boundary_condition) scm_to_int(s_3); 
  }
  (arg1)->set_boundary(arg2,arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_use_bloch__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-use-bloch"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  (arg1)->use_bloch(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_use_bloch__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-use-bloch"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  std::complex< double > arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[2]);
    arg3 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->use_bloch(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_use_bloch__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-use-bloch"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  (arg1)->use_bloch((meep::vec const &)*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_use_bloch(SCM rest)
{
#define FUNC_NAME "meep-fields-use-bloch"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-fields-use-bloch");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        return _wrap_meep_fields_use_bloch__SWIG_2(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_use_bloch__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SwigComplex_Check(argv[2]);
        }
        if (_v) {
          return _wrap_meep_fields_use_bloch__SWIG_1(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-use-bloch", "No matching method for generic function `meep_fields_use_bloch'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_lattice_vector (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-lattice-vector"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = ((meep::fields const *)arg1)->lattice_vector(arg2);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_update_eh__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-update-eh"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::field_type arg2 ;
  bool arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::field_type) scm_to_int(argv[1]); 
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  (arg1)->update_eh(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_update_eh__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-update-eh"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::field_type arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::field_type) scm_to_int(argv[1]); 
  }
  (arg1)->update_eh(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_update_eh(SCM rest)
{
#define FUNC_NAME "meep-fields-update-eh"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-fields-update-eh");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_fields_update_eh__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_update_eh__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-update-eh", "No matching method for generic function `meep_fields_update_eh'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_total_volume (SCM s_0)
{
#define FUNC_NAME "meep-fields-total-volume"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::volume > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = ((meep::fields const *)arg1)->total_volume();
  {
    meep::volume * resultptr;
    resultptr = new meep::volume((const meep::volume &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__volume, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_dump__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-dump"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  (arg1)->dump((char const *)arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_dump__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-dump"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  (arg1)->dump((char const *)arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_dump(SCM rest)
{
#define FUNC_NAME "meep-fields-dump"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-fields-dump");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_fields_dump__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_dump__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-dump", "No matching method for generic function `meep_fields_dump'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_load__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-load"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (bool) scm_is_true(argv[2]);
  }
  (arg1)->load((char const *)arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_load__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-load"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  (arg1)->load((char const *)arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_load(SCM rest)
{
#define FUNC_NAME "meep-fields-load"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-fields-load");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_fields_load__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_BOOLP(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_load__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-load", "No matching method for generic function `meep_fields_load'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  meep::component *arg5 = (meep::component *) 0 ;
  meep::field_function arg6 = (meep::field_function) 0 ;
  void *arg7 = (void *) 0 ;
  int arg8 ;
  meep::volume *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  double arg12 ;
  int must_free3 = 0 ;
  my_field_func_data data4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = list_length(gh_car(argv[3]));
    arg5 = new meep::component[arg4];
    for (int i = 0; i < arg4; ++i)
    arg5[i] = meep::component(integer_list_ref(gh_car(argv[3]), i));
    data4.nf = arg4;
    data4.func = gh_cdr(argv[3]);
    arg6 = my_field_func;
    arg7 = &data4;
  }
  {
    arg8 = (int) scm_to_int(argv[4]);
  }
  {
    arg9 = (meep::volume *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__volume, 9, 0);
  }
  {
    arg10 = (bool) scm_is_true(argv[6]);
  }
  {
    arg11 = (bool) scm_is_true(argv[7]);
  }
  {
    arg12 = (double) scm_to_double(argv[8]);
  }
  (arg1)->output_hdf5(arg2,(char const *)arg3,arg4,(meep::component const *)arg5,arg6,arg7,arg8,(meep::volume const &)*arg9,arg10,arg11,arg12);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  {
    if (arg5) delete[] arg5;
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  meep::component *arg5 = (meep::component *) 0 ;
  meep::field_function arg6 = (meep::field_function) 0 ;
  void *arg7 = (void *) 0 ;
  int arg8 ;
  meep::volume *arg9 = 0 ;
  bool arg10 ;
  bool arg11 ;
  int must_free3 = 0 ;
  my_field_func_data data4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = list_length(gh_car(argv[3]));
    arg5 = new meep::component[arg4];
    for (int i = 0; i < arg4; ++i)
    arg5[i] = meep::component(integer_list_ref(gh_car(argv[3]), i));
    data4.nf = arg4;
    data4.func = gh_cdr(argv[3]);
    arg6 = my_field_func;
    arg7 = &data4;
  }
  {
    arg8 = (int) scm_to_int(argv[4]);
  }
  {
    arg9 = (meep::volume *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__volume, 9, 0);
  }
  {
    arg10 = (bool) scm_is_true(argv[6]);
  }
  {
    arg11 = (bool) scm_is_true(argv[7]);
  }
  (arg1)->output_hdf5(arg2,(char const *)arg3,arg4,(meep::component const *)arg5,arg6,arg7,arg8,(meep::volume const &)*arg9,arg10,arg11);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  {
    if (arg5) delete[] arg5;
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  meep::component *arg5 = (meep::component *) 0 ;
  meep::field_function arg6 = (meep::field_function) 0 ;
  void *arg7 = (void *) 0 ;
  int arg8 ;
  meep::volume *arg9 = 0 ;
  bool arg10 ;
  int must_free3 = 0 ;
  my_field_func_data data4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = list_length(gh_car(argv[3]));
    arg5 = new meep::component[arg4];
    for (int i = 0; i < arg4; ++i)
    arg5[i] = meep::component(integer_list_ref(gh_car(argv[3]), i));
    data4.nf = arg4;
    data4.func = gh_cdr(argv[3]);
    arg6 = my_field_func;
    arg7 = &data4;
  }
  {
    arg8 = (int) scm_to_int(argv[4]);
  }
  {
    arg9 = (meep::volume *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__volume, 9, 0);
  }
  {
    arg10 = (bool) scm_is_true(argv[6]);
  }
  (arg1)->output_hdf5(arg2,(char const *)arg3,arg4,(meep::component const *)arg5,arg6,arg7,arg8,(meep::volume const &)*arg9,arg10);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  {
    if (arg5) delete[] arg5;
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::h5file *arg2 = (meep::h5file *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  meep::component *arg5 = (meep::component *) 0 ;
  meep::field_function arg6 = (meep::field_function) 0 ;
  void *arg7 = (void *) 0 ;
  int arg8 ;
  meep::volume *arg9 = 0 ;
  int must_free3 = 0 ;
  my_field_func_data data4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::h5file *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__h5file, 2, 0);
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = list_length(gh_car(argv[3]));
    arg5 = new meep::component[arg4];
    for (int i = 0; i < arg4; ++i)
    arg5[i] = meep::component(integer_list_ref(gh_car(argv[3]), i));
    data4.nf = arg4;
    data4.func = gh_cdr(argv[3]);
    arg6 = my_field_func;
    arg7 = &data4;
  }
  {
    arg8 = (int) scm_to_int(argv[4]);
  }
  {
    arg9 = (meep::volume *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__volume, 9, 0);
  }
  (arg1)->output_hdf5(arg2,(char const *)arg3,arg4,(meep::component const *)arg5,arg6,arg7,arg8,(meep::volume const &)*arg9);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free3 && arg3) SWIG_free(arg3);
  {
    if (arg5) delete[] arg5;
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  meep::field_function arg5 = (meep::field_function) 0 ;
  void *arg6 = (void *) 0 ;
  meep::volume *arg7 = 0 ;
  meep::h5file *arg8 = (meep::h5file *) 0 ;
  bool arg9 ;
  bool arg10 ;
  char *arg11 = (char *) 0 ;
  bool arg12 ;
  double arg13 ;
  int must_free2 = 0 ;
  my_field_func_data data3 ;
  int must_free11 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = list_length(gh_car(argv[2]));
    arg4 = new meep::component[arg3];
    for (int i = 0; i < arg3; ++i)
    arg4[i] = meep::component(integer_list_ref(gh_car(argv[2]), i));
    data3.nf = arg3;
    data3.func = gh_cdr(argv[2]);
    arg5 = my_field_func;
    arg6 = &data3;
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 7, 0);
  }
  {
    arg8 = (meep::h5file *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__h5file, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[5]);
  }
  {
    arg10 = (bool) scm_is_true(argv[6]);
  }
  {
    arg11 = (char *)SWIG_scm2str(argv[7]);
    must_free11 = 1;
  }
  {
    arg12 = (bool) scm_is_true(argv[8]);
  }
  {
    arg13 = (double) scm_to_double(argv[9]);
  }
  (arg1)->output_hdf5((char const *)arg2,arg3,(meep::component const *)arg4,arg5,arg6,(meep::volume const &)*arg7,arg8,arg9,arg10,(char const *)arg11,arg12,arg13);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  {
    if (arg4) delete[] arg4;
  }
  
  
  if (must_free11 && arg11) SWIG_free(arg11);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  meep::field_function arg5 = (meep::field_function) 0 ;
  void *arg6 = (void *) 0 ;
  meep::volume *arg7 = 0 ;
  meep::h5file *arg8 = (meep::h5file *) 0 ;
  bool arg9 ;
  bool arg10 ;
  char *arg11 = (char *) 0 ;
  bool arg12 ;
  int must_free2 = 0 ;
  my_field_func_data data3 ;
  int must_free11 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = list_length(gh_car(argv[2]));
    arg4 = new meep::component[arg3];
    for (int i = 0; i < arg3; ++i)
    arg4[i] = meep::component(integer_list_ref(gh_car(argv[2]), i));
    data3.nf = arg3;
    data3.func = gh_cdr(argv[2]);
    arg5 = my_field_func;
    arg6 = &data3;
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 7, 0);
  }
  {
    arg8 = (meep::h5file *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__h5file, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[5]);
  }
  {
    arg10 = (bool) scm_is_true(argv[6]);
  }
  {
    arg11 = (char *)SWIG_scm2str(argv[7]);
    must_free11 = 1;
  }
  {
    arg12 = (bool) scm_is_true(argv[8]);
  }
  (arg1)->output_hdf5((char const *)arg2,arg3,(meep::component const *)arg4,arg5,arg6,(meep::volume const &)*arg7,arg8,arg9,arg10,(char const *)arg11,arg12);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  {
    if (arg4) delete[] arg4;
  }
  
  
  if (must_free11 && arg11) SWIG_free(arg11);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  meep::field_function arg5 = (meep::field_function) 0 ;
  void *arg6 = (void *) 0 ;
  meep::volume *arg7 = 0 ;
  meep::h5file *arg8 = (meep::h5file *) 0 ;
  bool arg9 ;
  bool arg10 ;
  char *arg11 = (char *) 0 ;
  int must_free2 = 0 ;
  my_field_func_data data3 ;
  int must_free11 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = list_length(gh_car(argv[2]));
    arg4 = new meep::component[arg3];
    for (int i = 0; i < arg3; ++i)
    arg4[i] = meep::component(integer_list_ref(gh_car(argv[2]), i));
    data3.nf = arg3;
    data3.func = gh_cdr(argv[2]);
    arg5 = my_field_func;
    arg6 = &data3;
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 7, 0);
  }
  {
    arg8 = (meep::h5file *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__h5file, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[5]);
  }
  {
    arg10 = (bool) scm_is_true(argv[6]);
  }
  {
    arg11 = (char *)SWIG_scm2str(argv[7]);
    must_free11 = 1;
  }
  (arg1)->output_hdf5((char const *)arg2,arg3,(meep::component const *)arg4,arg5,arg6,(meep::volume const &)*arg7,arg8,arg9,arg10,(char const *)arg11);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  {
    if (arg4) delete[] arg4;
  }
  
  
  if (must_free11 && arg11) SWIG_free(arg11);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  meep::field_function arg5 = (meep::field_function) 0 ;
  void *arg6 = (void *) 0 ;
  meep::volume *arg7 = 0 ;
  meep::h5file *arg8 = (meep::h5file *) 0 ;
  bool arg9 ;
  bool arg10 ;
  int must_free2 = 0 ;
  my_field_func_data data3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = list_length(gh_car(argv[2]));
    arg4 = new meep::component[arg3];
    for (int i = 0; i < arg3; ++i)
    arg4[i] = meep::component(integer_list_ref(gh_car(argv[2]), i));
    data3.nf = arg3;
    data3.func = gh_cdr(argv[2]);
    arg5 = my_field_func;
    arg6 = &data3;
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 7, 0);
  }
  {
    arg8 = (meep::h5file *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__h5file, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[5]);
  }
  {
    arg10 = (bool) scm_is_true(argv[6]);
  }
  (arg1)->output_hdf5((char const *)arg2,arg3,(meep::component const *)arg4,arg5,arg6,(meep::volume const &)*arg7,arg8,arg9,arg10);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  {
    if (arg4) delete[] arg4;
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_8 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  meep::field_function arg5 = (meep::field_function) 0 ;
  void *arg6 = (void *) 0 ;
  meep::volume *arg7 = 0 ;
  meep::h5file *arg8 = (meep::h5file *) 0 ;
  bool arg9 ;
  int must_free2 = 0 ;
  my_field_func_data data3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = list_length(gh_car(argv[2]));
    arg4 = new meep::component[arg3];
    for (int i = 0; i < arg3; ++i)
    arg4[i] = meep::component(integer_list_ref(gh_car(argv[2]), i));
    data3.nf = arg3;
    data3.func = gh_cdr(argv[2]);
    arg5 = my_field_func;
    arg6 = &data3;
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 7, 0);
  }
  {
    arg8 = (meep::h5file *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__h5file, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[5]);
  }
  (arg1)->output_hdf5((char const *)arg2,arg3,(meep::component const *)arg4,arg5,arg6,(meep::volume const &)*arg7,arg8,arg9);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  {
    if (arg4) delete[] arg4;
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_9 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  meep::field_function arg5 = (meep::field_function) 0 ;
  void *arg6 = (void *) 0 ;
  meep::volume *arg7 = 0 ;
  meep::h5file *arg8 = (meep::h5file *) 0 ;
  int must_free2 = 0 ;
  my_field_func_data data3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = list_length(gh_car(argv[2]));
    arg4 = new meep::component[arg3];
    for (int i = 0; i < arg3; ++i)
    arg4[i] = meep::component(integer_list_ref(gh_car(argv[2]), i));
    data3.nf = arg3;
    data3.func = gh_cdr(argv[2]);
    arg5 = my_field_func;
    arg6 = &data3;
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 7, 0);
  }
  {
    arg8 = (meep::h5file *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__h5file, 8, 0);
  }
  (arg1)->output_hdf5((char const *)arg2,arg3,(meep::component const *)arg4,arg5,arg6,(meep::volume const &)*arg7,arg8);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  {
    if (arg4) delete[] arg4;
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_10 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  meep::field_function arg5 = (meep::field_function) 0 ;
  void *arg6 = (void *) 0 ;
  meep::volume *arg7 = 0 ;
  int must_free2 = 0 ;
  my_field_func_data data3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = list_length(gh_car(argv[2]));
    arg4 = new meep::component[arg3];
    for (int i = 0; i < arg3; ++i)
    arg4[i] = meep::component(integer_list_ref(gh_car(argv[2]), i));
    data3.nf = arg3;
    data3.func = gh_cdr(argv[2]);
    arg5 = my_field_func;
    arg6 = &data3;
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 7, 0);
  }
  (arg1)->output_hdf5((char const *)arg2,arg3,(meep::component const *)arg4,arg5,arg6,(meep::volume const &)*arg7);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  {
    if (arg4) delete[] arg4;
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_11 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  meep::field_rfunction arg5 = (meep::field_rfunction) 0 ;
  void *arg6 = (void *) 0 ;
  meep::volume *arg7 = 0 ;
  meep::h5file *arg8 = (meep::h5file *) 0 ;
  bool arg9 ;
  bool arg10 ;
  char *arg11 = (char *) 0 ;
  double arg12 ;
  int must_free2 = 0 ;
  int must_free11 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (meep::component *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__component, 4, 0);
  }
  {
    arg5 = (meep::field_rfunction)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(argv[5], NULL, 6, 0);
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__volume, 7, 0);
  }
  {
    arg8 = (meep::h5file *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__h5file, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  {
    arg10 = (bool) scm_is_true(argv[9]);
  }
  {
    arg11 = (char *)SWIG_scm2str(argv[10]);
    must_free11 = 1;
  }
  {
    arg12 = (double) scm_to_double(argv[11]);
  }
  (arg1)->output_hdf5((char const *)arg2,arg3,(meep::component const *)arg4,arg5,arg6,(meep::volume const &)*arg7,arg8,arg9,arg10,(char const *)arg11,arg12);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  
  
  
  if (must_free11 && arg11) SWIG_free(arg11);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_12 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  meep::field_rfunction arg5 = (meep::field_rfunction) 0 ;
  void *arg6 = (void *) 0 ;
  meep::volume *arg7 = 0 ;
  meep::h5file *arg8 = (meep::h5file *) 0 ;
  bool arg9 ;
  bool arg10 ;
  char *arg11 = (char *) 0 ;
  int must_free2 = 0 ;
  int must_free11 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (meep::component *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__component, 4, 0);
  }
  {
    arg5 = (meep::field_rfunction)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(argv[5], NULL, 6, 0);
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__volume, 7, 0);
  }
  {
    arg8 = (meep::h5file *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__h5file, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  {
    arg10 = (bool) scm_is_true(argv[9]);
  }
  {
    arg11 = (char *)SWIG_scm2str(argv[10]);
    must_free11 = 1;
  }
  (arg1)->output_hdf5((char const *)arg2,arg3,(meep::component const *)arg4,arg5,arg6,(meep::volume const &)*arg7,arg8,arg9,arg10,(char const *)arg11);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  
  
  
  if (must_free11 && arg11) SWIG_free(arg11);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_13 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  meep::field_rfunction arg5 = (meep::field_rfunction) 0 ;
  void *arg6 = (void *) 0 ;
  meep::volume *arg7 = 0 ;
  meep::h5file *arg8 = (meep::h5file *) 0 ;
  bool arg9 ;
  bool arg10 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (meep::component *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__component, 4, 0);
  }
  {
    arg5 = (meep::field_rfunction)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(argv[5], NULL, 6, 0);
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__volume, 7, 0);
  }
  {
    arg8 = (meep::h5file *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__h5file, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  {
    arg10 = (bool) scm_is_true(argv[9]);
  }
  (arg1)->output_hdf5((char const *)arg2,arg3,(meep::component const *)arg4,arg5,arg6,(meep::volume const &)*arg7,arg8,arg9,arg10);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_14 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  meep::field_rfunction arg5 = (meep::field_rfunction) 0 ;
  void *arg6 = (void *) 0 ;
  meep::volume *arg7 = 0 ;
  meep::h5file *arg8 = (meep::h5file *) 0 ;
  bool arg9 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (meep::component *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__component, 4, 0);
  }
  {
    arg5 = (meep::field_rfunction)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(argv[5], NULL, 6, 0);
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__volume, 7, 0);
  }
  {
    arg8 = (meep::h5file *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__h5file, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  (arg1)->output_hdf5((char const *)arg2,arg3,(meep::component const *)arg4,arg5,arg6,(meep::volume const &)*arg7,arg8,arg9);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_15 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  meep::field_rfunction arg5 = (meep::field_rfunction) 0 ;
  void *arg6 = (void *) 0 ;
  meep::volume *arg7 = 0 ;
  meep::h5file *arg8 = (meep::h5file *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (meep::component *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__component, 4, 0);
  }
  {
    arg5 = (meep::field_rfunction)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(argv[5], NULL, 6, 0);
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__volume, 7, 0);
  }
  {
    arg8 = (meep::h5file *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__h5file, 8, 0);
  }
  (arg1)->output_hdf5((char const *)arg2,arg3,(meep::component const *)arg4,arg5,arg6,(meep::volume const &)*arg7,arg8);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_16 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  meep::field_rfunction arg5 = (meep::field_rfunction) 0 ;
  void *arg6 = (void *) 0 ;
  meep::volume *arg7 = 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (meep::component *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__component, 4, 0);
  }
  {
    arg5 = (meep::field_rfunction)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(argv[5], NULL, 6, 0);
  }
  {
    arg7 = (meep::volume *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__volume, 7, 0);
  }
  (arg1)->output_hdf5((char const *)arg2,arg3,(meep::component const *)arg4,arg5,arg6,(meep::volume const &)*arg7);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_17 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  meep::h5file *arg4 = (meep::h5file *) 0 ;
  bool arg5 ;
  bool arg6 ;
  char *arg7 = (char *) 0 ;
  double arg8 ;
  int must_free7 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (meep::h5file *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__h5file, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (char *)SWIG_scm2str(argv[6]);
    must_free7 = 1;
  }
  {
    arg8 = (double) scm_to_double(argv[7]);
  }
  (arg1)->output_hdf5(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,(char const *)arg7,arg8);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  if (must_free7 && arg7) SWIG_free(arg7);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_18 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  meep::h5file *arg4 = (meep::h5file *) 0 ;
  bool arg5 ;
  bool arg6 ;
  char *arg7 = (char *) 0 ;
  int must_free7 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (meep::h5file *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__h5file, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (char *)SWIG_scm2str(argv[6]);
    must_free7 = 1;
  }
  (arg1)->output_hdf5(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,(char const *)arg7);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  if (must_free7 && arg7) SWIG_free(arg7);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_19 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  meep::h5file *arg4 = (meep::h5file *) 0 ;
  bool arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (meep::h5file *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__h5file, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  (arg1)->output_hdf5(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_20 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  meep::h5file *arg4 = (meep::h5file *) 0 ;
  bool arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (meep::h5file *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__h5file, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  (arg1)->output_hdf5(arg2,(meep::volume const &)*arg3,arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_21 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  meep::h5file *arg4 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (meep::h5file *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__h5file, 4, 0);
  }
  (arg1)->output_hdf5(arg2,(meep::volume const &)*arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_22 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  (arg1)->output_hdf5(arg2,(meep::volume const &)*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_23 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::derived_component arg2 ;
  meep::volume *arg3 = 0 ;
  meep::h5file *arg4 = (meep::h5file *) 0 ;
  bool arg5 ;
  bool arg6 ;
  char *arg7 = (char *) 0 ;
  double arg8 ;
  int must_free7 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::derived_component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (meep::h5file *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__h5file, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (char *)SWIG_scm2str(argv[6]);
    must_free7 = 1;
  }
  {
    arg8 = (double) scm_to_double(argv[7]);
  }
  (arg1)->output_hdf5(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,(char const *)arg7,arg8);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  if (must_free7 && arg7) SWIG_free(arg7);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_24 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::derived_component arg2 ;
  meep::volume *arg3 = 0 ;
  meep::h5file *arg4 = (meep::h5file *) 0 ;
  bool arg5 ;
  bool arg6 ;
  char *arg7 = (char *) 0 ;
  int must_free7 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::derived_component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (meep::h5file *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__h5file, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (char *)SWIG_scm2str(argv[6]);
    must_free7 = 1;
  }
  (arg1)->output_hdf5(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,(char const *)arg7);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  if (must_free7 && arg7) SWIG_free(arg7);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_25 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::derived_component arg2 ;
  meep::volume *arg3 = 0 ;
  meep::h5file *arg4 = (meep::h5file *) 0 ;
  bool arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::derived_component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (meep::h5file *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__h5file, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  (arg1)->output_hdf5(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_26 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::derived_component arg2 ;
  meep::volume *arg3 = 0 ;
  meep::h5file *arg4 = (meep::h5file *) 0 ;
  bool arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::derived_component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (meep::h5file *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__h5file, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  (arg1)->output_hdf5(arg2,(meep::volume const &)*arg3,arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_27 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::derived_component arg2 ;
  meep::volume *arg3 = 0 ;
  meep::h5file *arg4 = (meep::h5file *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::derived_component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (meep::h5file *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__h5file, 4, 0);
  }
  (arg1)->output_hdf5(arg2,(meep::volume const &)*arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5__SWIG_28 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::derived_component arg2 ;
  meep::volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::derived_component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  (arg1)->output_hdf5(arg2,(meep::volume const &)*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_hdf5(SCM rest)
{
#define FUNC_NAME "meep-fields-output-hdf5"
  SCM argv[12];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 12, "meep-fields-output-hdf5");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_output_hdf5__SWIG_22(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_output_hdf5__SWIG_28(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__h5file, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_output_hdf5__SWIG_27(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__h5file, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_output_hdf5__SWIG_21(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_NFALSEP(scm_pair_p(argv[2])) &&
          SCM_NFALSEP(scm_list_p(gh_car(argv[2]))) &&
          SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[2])));
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_output_hdf5__SWIG_10(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__h5file, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_output_hdf5__SWIG_26(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__h5file, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_output_hdf5__SWIG_20(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_NFALSEP(scm_pair_p(argv[2])) &&
          SCM_NFALSEP(scm_list_p(gh_car(argv[2]))) &&
          SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[2])));
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__h5file, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_fields_output_hdf5__SWIG_9(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = SCM_NFALSEP(scm_pair_p(argv[3])) &&
            SCM_NFALSEP(scm_list_p(gh_car(argv[3]))) &&
            SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[3])));
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_meep_fields_output_hdf5__SWIG_3(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__h5file, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_output_hdf5__SWIG_25(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__h5file, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_output_hdf5__SWIG_19(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_NFALSEP(scm_pair_p(argv[2])) &&
          SCM_NFALSEP(scm_list_p(gh_car(argv[2]))) &&
          SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[2])));
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__h5file, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_output_hdf5__SWIG_8(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = SCM_NFALSEP(scm_pair_p(argv[3])) &&
            SCM_NFALSEP(scm_list_p(gh_car(argv[3]))) &&
            SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[3])));
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_output_hdf5__SWIG_2(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__h5file, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_string(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_output_hdf5__SWIG_24(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__h5file, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_string(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_output_hdf5__SWIG_18(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_NFALSEP(scm_pair_p(argv[2])) &&
          SCM_NFALSEP(scm_list_p(gh_car(argv[2]))) &&
          SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[2])));
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__h5file, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_output_hdf5__SWIG_7(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__component, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_meep_fields_output_hdf5__SWIG_16(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = SCM_NFALSEP(scm_pair_p(argv[3])) &&
            SCM_NFALSEP(scm_list_p(gh_car(argv[3]))) &&
            SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[3])));
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_output_hdf5__SWIG_1(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__h5file, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_string(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_real_p(argv[7])) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_output_hdf5__SWIG_17(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__h5file, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_string(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_real_p(argv[7])) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_output_hdf5__SWIG_23(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_NFALSEP(scm_pair_p(argv[2])) &&
          SCM_NFALSEP(scm_list_p(gh_car(argv[2]))) &&
          SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[2])));
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__h5file, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_string(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_output_hdf5__SWIG_6(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__component, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__h5file, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_meep_fields_output_hdf5__SWIG_15(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__h5file, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = SCM_NFALSEP(scm_pair_p(argv[3])) &&
            SCM_NFALSEP(scm_list_p(gh_car(argv[3]))) &&
            SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[3])));
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_real_p(argv[8])) ? 1 : 0;
                    }
                    if (_v) {
                      return _wrap_meep_fields_output_hdf5__SWIG_0(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_NFALSEP(scm_pair_p(argv[2])) &&
          SCM_NFALSEP(scm_list_p(gh_car(argv[2]))) &&
          SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[2])));
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__h5file, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_string(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      return _wrap_meep_fields_output_hdf5__SWIG_5(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__component, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__h5file, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      return _wrap_meep_fields_output_hdf5__SWIG_14(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = SCM_NFALSEP(scm_pair_p(argv[2])) &&
          SCM_NFALSEP(scm_list_p(gh_car(argv[2]))) &&
          SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[2])));
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__h5file, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_string(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = scm_is_true(scm_real_p(argv[9])) ? 1 : 0;
                      }
                      if (_v) {
                        return _wrap_meep_fields_output_hdf5__SWIG_4(argc,argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__component, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__h5file, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = SCM_BOOLP(argv[9]) ? 1 : 0;
                      }
                      if (_v) {
                        return _wrap_meep_fields_output_hdf5__SWIG_13(argc,argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__component, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__h5file, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = SCM_BOOLP(argv[9]) ? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = scm_is_string(argv[10]) ? 1 : 0;
                        }
                        if (_v) {
                          return _wrap_meep_fields_output_hdf5__SWIG_12(argc,argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__component, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__h5file, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = SCM_BOOLP(argv[9]) ? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = scm_is_string(argv[10]) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            _v = scm_is_true(scm_real_p(argv[11])) ? 1 : 0;
                          }
                          if (_v) {
                            return _wrap_meep_fields_output_hdf5__SWIG_11(argc,argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-output-hdf5", "No matching method for generic function `meep_fields_output_hdf5'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_open_h5file__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-open-h5file"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  meep::h5file::access_mode arg3 ;
  char *arg4 = (char *) 0 ;
  bool arg5 ;
  int must_free2 = 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::h5file *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (meep::h5file::access_mode) scm_to_int(argv[2]); 
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  result = (meep::h5file *)(arg1)->open_h5file((char const *)arg2,arg3,(char const *)arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__h5file, 1);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_open_h5file__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-open-h5file"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  meep::h5file::access_mode arg3 ;
  char *arg4 = (char *) 0 ;
  int must_free2 = 0 ;
  int must_free4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::h5file *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (meep::h5file::access_mode) scm_to_int(argv[2]); 
  }
  {
    arg4 = (char *)SWIG_scm2str(argv[3]);
    must_free4 = 1;
  }
  result = (meep::h5file *)(arg1)->open_h5file((char const *)arg2,arg3,(char const *)arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__h5file, 1);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  if (must_free4 && arg4) SWIG_free(arg4);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_open_h5file__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-open-h5file"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  meep::h5file::access_mode arg3 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::h5file *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (meep::h5file::access_mode) scm_to_int(argv[2]); 
  }
  result = (meep::h5file *)(arg1)->open_h5file((char const *)arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__h5file, 1);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_open_h5file__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-open-h5file"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::h5file *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  result = (meep::h5file *)(arg1)->open_h5file((char const *)arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__h5file, 1);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_open_h5file(SCM rest)
{
#define FUNC_NAME "meep-fields-open-h5file"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-fields-open-h5file");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_fields_open_h5file__SWIG_3(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_open_h5file__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_open_h5file__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_string(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_open_h5file__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-open-h5file", "No matching method for generic function `meep_fields_open_h5file'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_h5file_name__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-h5file-name"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  bool arg4 ;
  int must_free2 = 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  result = (char *)(arg1)->h5file_name((char const *)arg2,(char const *)arg3,arg4);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_h5file_name__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-h5file-name"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  int must_free2 = 0 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  result = (char *)(arg1)->h5file_name((char const *)arg2,(char const *)arg3);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_h5file_name__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-h5file-name"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  result = (char *)(arg1)->h5file_name((char const *)arg2);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_h5file_name(SCM rest)
{
#define FUNC_NAME "meep-fields-h5file-name"
  SCM argv[4];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 4, "meep-fields-h5file-name");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_fields_h5file_name__SWIG_2(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_h5file_name__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_h5file_name__SWIG_0(argc,argv);
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-h5file-name", "No matching method for generic function `meep_fields_h5file_name'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_times (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-output-times"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  (arg1)->output_times((char const *)arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice_dimensions__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice-dimensions"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  size_t *arg3 ;
  meep::direction *arg4 ;
  bool arg5 ;
  bool arg6 ;
  meep::vec *arg7 = (meep::vec *) 0 ;
  void *arg8 = (void *) 0 ;
  meep::component arg9 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_size_t, 3, 0);
  }
  {
    arg4 = (meep::direction *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__direction, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (meep::vec *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__vec, 7, 0);
  }
  {
    arg8 = (void *)SWIG_MustGetPtr(argv[7], NULL, 8, 0);
  }
  {
    arg9 = (meep::component) scm_to_int(argv[8]); 
  }
  result = (int)(arg1)->get_array_slice_dimensions((meep::volume const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice_dimensions__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice-dimensions"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  size_t *arg3 ;
  meep::direction *arg4 ;
  bool arg5 ;
  bool arg6 ;
  meep::vec *arg7 = (meep::vec *) 0 ;
  void *arg8 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_size_t, 3, 0);
  }
  {
    arg4 = (meep::direction *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__direction, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (meep::vec *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__vec, 7, 0);
  }
  {
    arg8 = (void *)SWIG_MustGetPtr(argv[7], NULL, 8, 0);
  }
  result = (int)(arg1)->get_array_slice_dimensions((meep::volume const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice_dimensions__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice-dimensions"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  size_t *arg3 ;
  meep::direction *arg4 ;
  bool arg5 ;
  bool arg6 ;
  meep::vec *arg7 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_size_t, 3, 0);
  }
  {
    arg4 = (meep::direction *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__direction, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (meep::vec *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__vec, 7, 0);
  }
  result = (int)(arg1)->get_array_slice_dimensions((meep::volume const &)*arg2,arg3,arg4,arg5,arg6,arg7);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice_dimensions__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice-dimensions"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  size_t *arg3 ;
  meep::direction *arg4 ;
  bool arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_size_t, 3, 0);
  }
  {
    arg4 = (meep::direction *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__direction, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = (int)(arg1)->get_array_slice_dimensions((meep::volume const &)*arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice_dimensions__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice-dimensions"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  size_t *arg3 ;
  meep::direction *arg4 ;
  bool arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_size_t, 3, 0);
  }
  {
    arg4 = (meep::direction *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__direction, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  result = (int)(arg1)->get_array_slice_dimensions((meep::volume const &)*arg2,arg3,arg4,arg5);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice_dimensions__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice-dimensions"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  size_t *arg3 ;
  meep::direction *arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (size_t *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_size_t, 3, 0);
  }
  {
    arg4 = (meep::direction *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__direction, 4, 0);
  }
  result = (int)(arg1)->get_array_slice_dimensions((meep::volume const &)*arg2,arg3,arg4);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice_dimensions(SCM rest)
{
#define FUNC_NAME "meep-fields-get-array-slice-dimensions"
  SCM argv[9];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 9, "meep-fields-get-array-slice-dimensions");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_size_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__direction, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_get_array_slice_dimensions__SWIG_5(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_size_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__direction, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_get_array_slice_dimensions__SWIG_4(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_size_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__direction, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_get_array_slice_dimensions__SWIG_3(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_size_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__direction, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__vec, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_meep_fields_get_array_slice_dimensions__SWIG_2(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_size_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__direction, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__vec, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, 0, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_meep_fields_get_array_slice_dimensions__SWIG_1(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_size_t, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__direction, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__vec, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, 0, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_integer_p(argv[8])) && scm_is_true(scm_exact_p(argv[8]))? 1 : 0;
                    }
                    if (_v) {
                      return _wrap_meep_fields_get_array_slice_dimensions__SWIG_0(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-get-array-slice-dimensions", "No matching method for generic function `meep_fields_get_array_slice_dimensions'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  std::vector< meep::component > arg3 ;
  meep::field_rfunction arg4 = (meep::field_rfunction) 0 ;
  void *arg5 = (void *) 0 ;
  meep::realnum *arg6 = (meep::realnum *) 0 ;
  double arg7 ;
  bool arg8 ;
  std::vector< meep::component > *argp3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    argp3 = (std::vector< meep::component > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_meep__component_t, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = (meep::field_rfunction)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(argv[4], NULL, 5, 0);
  }
  {
    arg6 = (meep::realnum *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_double, 6, 0);
  }
  {
    arg7 = (double) scm_to_double(argv[6]);
  }
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  result = (meep::realnum *)(arg1)->get_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  std::vector< meep::component > arg3 ;
  meep::field_rfunction arg4 = (meep::field_rfunction) 0 ;
  void *arg5 = (void *) 0 ;
  meep::realnum *arg6 = (meep::realnum *) 0 ;
  double arg7 ;
  std::vector< meep::component > *argp3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    argp3 = (std::vector< meep::component > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_meep__component_t, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = (meep::field_rfunction)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(argv[4], NULL, 5, 0);
  }
  {
    arg6 = (meep::realnum *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_double, 6, 0);
  }
  {
    arg7 = (double) scm_to_double(argv[6]);
  }
  result = (meep::realnum *)(arg1)->get_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5,arg6,arg7);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  std::vector< meep::component > arg3 ;
  meep::field_rfunction arg4 = (meep::field_rfunction) 0 ;
  void *arg5 = (void *) 0 ;
  meep::realnum *arg6 = (meep::realnum *) 0 ;
  std::vector< meep::component > *argp3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    argp3 = (std::vector< meep::component > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_meep__component_t, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = (meep::field_rfunction)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(argv[4], NULL, 5, 0);
  }
  {
    arg6 = (meep::realnum *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_double, 6, 0);
  }
  result = (meep::realnum *)(arg1)->get_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  std::vector< meep::component > arg3 ;
  meep::field_rfunction arg4 = (meep::field_rfunction) 0 ;
  void *arg5 = (void *) 0 ;
  std::vector< meep::component > *argp3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    argp3 = (std::vector< meep::component > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_meep__component_t, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = (meep::field_rfunction)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(argv[4], NULL, 5, 0);
  }
  result = (meep::realnum *)(arg1)->get_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_complex_array_slice__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-complex-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  std::vector< meep::component > arg3 ;
  meep::field_function arg4 = (meep::field_function) 0 ;
  void *arg5 = (void *) 0 ;
  std::complex< meep::realnum > *arg6 = (std::complex< meep::realnum > *) 0 ;
  double arg7 ;
  bool arg8 ;
  std::vector< meep::component > *argp3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    argp3 = (std::vector< meep::component > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_meep__component_t, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = (meep::field_function)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(argv[4], NULL, 5, 0);
  }
  {
    arg6 = (std::complex< meep::realnum > *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_std__complexT_double_t, 6, 0);
  }
  {
    arg7 = (double) scm_to_double(argv[6]);
  }
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  result = (std::complex< meep::realnum > *)(arg1)->get_complex_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_complex_array_slice__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-complex-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  std::vector< meep::component > arg3 ;
  meep::field_function arg4 = (meep::field_function) 0 ;
  void *arg5 = (void *) 0 ;
  std::complex< meep::realnum > *arg6 = (std::complex< meep::realnum > *) 0 ;
  double arg7 ;
  std::vector< meep::component > *argp3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    argp3 = (std::vector< meep::component > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_meep__component_t, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = (meep::field_function)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(argv[4], NULL, 5, 0);
  }
  {
    arg6 = (std::complex< meep::realnum > *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_std__complexT_double_t, 6, 0);
  }
  {
    arg7 = (double) scm_to_double(argv[6]);
  }
  result = (std::complex< meep::realnum > *)(arg1)->get_complex_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5,arg6,arg7);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_complex_array_slice__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-complex-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  std::vector< meep::component > arg3 ;
  meep::field_function arg4 = (meep::field_function) 0 ;
  void *arg5 = (void *) 0 ;
  std::complex< meep::realnum > *arg6 = (std::complex< meep::realnum > *) 0 ;
  std::vector< meep::component > *argp3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    argp3 = (std::vector< meep::component > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_meep__component_t, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = (meep::field_function)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(argv[4], NULL, 5, 0);
  }
  {
    arg6 = (std::complex< meep::realnum > *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_std__complexT_double_t, 6, 0);
  }
  result = (std::complex< meep::realnum > *)(arg1)->get_complex_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_complex_array_slice__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-complex-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  std::vector< meep::component > arg3 ;
  meep::field_function arg4 = (meep::field_function) 0 ;
  void *arg5 = (void *) 0 ;
  std::vector< meep::component > *argp3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    argp3 = (std::vector< meep::component > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_meep__component_t, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = (meep::field_function)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(argv[4], NULL, 5, 0);
  }
  result = (std::complex< meep::realnum > *)(arg1)->get_complex_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::component arg3 ;
  meep::realnum *arg4 = (meep::realnum *) 0 ;
  double arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::component) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::realnum *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = (meep::realnum *)(arg1)->get_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::component arg3 ;
  meep::realnum *arg4 = (meep::realnum *) 0 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::component) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::realnum *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = (meep::realnum *)(arg1)->get_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::component arg3 ;
  meep::realnum *arg4 = (meep::realnum *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::component) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::realnum *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  result = (meep::realnum *)(arg1)->get_array_slice((meep::volume const &)*arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::component arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::component) scm_to_int(argv[2]); 
  }
  result = (meep::realnum *)(arg1)->get_array_slice((meep::volume const &)*arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice__SWIG_8 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::derived_component arg3 ;
  meep::realnum *arg4 = (meep::realnum *) 0 ;
  double arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::derived_component) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::realnum *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = (meep::realnum *)(arg1)->get_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice__SWIG_9 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::derived_component arg3 ;
  meep::realnum *arg4 = (meep::realnum *) 0 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::derived_component) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::realnum *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = (meep::realnum *)(arg1)->get_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice__SWIG_10 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::derived_component arg3 ;
  meep::realnum *arg4 = (meep::realnum *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::derived_component) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::realnum *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  result = (meep::realnum *)(arg1)->get_array_slice((meep::volume const &)*arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice__SWIG_11 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::derived_component arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::realnum *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::derived_component) scm_to_int(argv[2]); 
  }
  result = (meep::realnum *)(arg1)->get_array_slice((meep::volume const &)*arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_double, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_slice(SCM rest)
{
#define FUNC_NAME "meep-fields-get-array-slice"
  SCM argv[8];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 8, "meep-fields-get-array-slice");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_get_array_slice__SWIG_7(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_get_array_slice__SWIG_11(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_get_array_slice__SWIG_10(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_get_array_slice__SWIG_6(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_meep__component_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_fields_get_array_slice__SWIG_3(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_get_array_slice__SWIG_9(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_get_array_slice__SWIG_5(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_meep__component_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_meep_fields_get_array_slice__SWIG_2(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_get_array_slice__SWIG_4(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_get_array_slice__SWIG_8(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_meep__component_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_get_array_slice__SWIG_1(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_meep__component_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_double, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_get_array_slice__SWIG_0(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-get-array-slice", "No matching method for generic function `meep_fields_get_array_slice'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_complex_array_slice__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-complex-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::component arg3 ;
  std::complex< meep::realnum > *arg4 = (std::complex< meep::realnum > *) 0 ;
  double arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::component) scm_to_int(argv[2]); 
  }
  {
    arg4 = (std::complex< meep::realnum > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__complexT_double_t, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = (std::complex< meep::realnum > *)(arg1)->get_complex_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_complex_array_slice__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-complex-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::component arg3 ;
  std::complex< meep::realnum > *arg4 = (std::complex< meep::realnum > *) 0 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::component) scm_to_int(argv[2]); 
  }
  {
    arg4 = (std::complex< meep::realnum > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__complexT_double_t, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = (std::complex< meep::realnum > *)(arg1)->get_complex_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_complex_array_slice__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-complex-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::component arg3 ;
  std::complex< meep::realnum > *arg4 = (std::complex< meep::realnum > *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::component) scm_to_int(argv[2]); 
  }
  {
    arg4 = (std::complex< meep::realnum > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__complexT_double_t, 4, 0);
  }
  result = (std::complex< meep::realnum > *)(arg1)->get_complex_array_slice((meep::volume const &)*arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_complex_array_slice__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-complex-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::component arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::component) scm_to_int(argv[2]); 
  }
  result = (std::complex< meep::realnum > *)(arg1)->get_complex_array_slice((meep::volume const &)*arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_complex_array_slice(SCM rest)
{
#define FUNC_NAME "meep-fields-get-complex-array-slice"
  SCM argv[8];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 8, "meep-fields-get-complex-array-slice");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_get_complex_array_slice__SWIG_7(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_get_complex_array_slice__SWIG_6(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_meep__component_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_fields_get_complex_array_slice__SWIG_3(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_get_complex_array_slice__SWIG_5(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_meep__component_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_meep_fields_get_complex_array_slice__SWIG_2(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_get_complex_array_slice__SWIG_4(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_meep__component_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_get_complex_array_slice__SWIG_1(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_meep__component_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_get_complex_array_slice__SWIG_0(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-get-complex-array-slice", "No matching method for generic function `meep_fields_get_complex_array_slice'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_source_slice__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-source-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::component arg3 ;
  std::complex< meep::realnum > *arg4 = (std::complex< meep::realnum > *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::component) scm_to_int(argv[2]); 
  }
  {
    arg4 = (std::complex< meep::realnum > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__complexT_double_t, 4, 0);
  }
  result = (std::complex< meep::realnum > *)(arg1)->get_source_slice((meep::volume const &)*arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_source_slice__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-source-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  meep::component arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (meep::component) scm_to_int(argv[2]); 
  }
  result = (std::complex< meep::realnum > *)(arg1)->get_source_slice((meep::volume const &)*arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_source_slice(SCM rest)
{
#define FUNC_NAME "meep-fields-get-source-slice"
  SCM argv[4];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 4, "meep-fields-get-source-slice");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_get_source_slice__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_get_source_slice__SWIG_0(argc,argv);
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-get-source-slice", "No matching method for generic function `meep_fields_get_source_slice'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_do_get_array_slice__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-do-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  std::vector< meep::component > arg3 ;
  meep::field_function arg4 = (meep::field_function) 0 ;
  meep::field_rfunction arg5 = (meep::field_rfunction) 0 ;
  void *arg6 = (void *) 0 ;
  void *arg7 = (void *) 0 ;
  double arg8 ;
  bool arg9 ;
  std::vector< meep::component > *argp3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    argp3 = (std::vector< meep::component > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_meep__component_t, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = (meep::field_function)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 4, 0);
  }
  {
    arg5 = (meep::field_rfunction)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(argv[5], NULL, 6, 0);
  }
  {
    arg7 = (void *)SWIG_MustGetPtr(argv[6], NULL, 7, 0);
  }
  {
    arg8 = (double) scm_to_double(argv[7]);
  }
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  result = (void *)(arg1)->do_get_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_do_get_array_slice__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-do-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  std::vector< meep::component > arg3 ;
  meep::field_function arg4 = (meep::field_function) 0 ;
  meep::field_rfunction arg5 = (meep::field_rfunction) 0 ;
  void *arg6 = (void *) 0 ;
  void *arg7 = (void *) 0 ;
  double arg8 ;
  std::vector< meep::component > *argp3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    argp3 = (std::vector< meep::component > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_meep__component_t, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = (meep::field_function)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 4, 0);
  }
  {
    arg5 = (meep::field_rfunction)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(argv[5], NULL, 6, 0);
  }
  {
    arg7 = (void *)SWIG_MustGetPtr(argv[6], NULL, 7, 0);
  }
  {
    arg8 = (double) scm_to_double(argv[7]);
  }
  result = (void *)(arg1)->do_get_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_do_get_array_slice__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-do-get-array-slice"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  std::vector< meep::component > arg3 ;
  meep::field_function arg4 = (meep::field_function) 0 ;
  meep::field_rfunction arg5 = (meep::field_rfunction) 0 ;
  void *arg6 = (void *) 0 ;
  void *arg7 = (void *) 0 ;
  std::vector< meep::component > *argp3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    argp3 = (std::vector< meep::component > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_meep__component_t, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = (meep::field_function)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 4, 0);
  }
  {
    arg5 = (meep::field_rfunction)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 5, 0);
  }
  {
    arg6 = (void *)SWIG_MustGetPtr(argv[5], NULL, 6, 0);
  }
  {
    arg7 = (void *)SWIG_MustGetPtr(argv[6], NULL, 7, 0);
  }
  result = (void *)(arg1)->do_get_array_slice((meep::volume const &)*arg2,arg3,arg4,arg5,arg6,arg7);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_do_get_array_slice(SCM rest)
{
#define FUNC_NAME "meep-fields-do-get-array-slice"
  SCM argv[9];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 9, "meep-fields-do-get-array-slice");
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_meep__component_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, 0, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_meep_fields_do_get_array_slice__SWIG_2(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_meep__component_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, 0, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_real_p(argv[7])) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_do_get_array_slice__SWIG_1(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_meep__component_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, 0, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_real_p(argv[7])) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      return _wrap_meep_fields_do_get_array_slice__SWIG_0(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-do-get-array-slice", "No matching method for generic function `meep_fields_do_get_array_slice'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_array_metadata (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-get-array-metadata"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  result = (arg1)->get_array_metadata((meep::volume const &)*arg2);
  {
    std::vector< double > * resultptr;
    resultptr = new std::vector< double >((const std::vector< double > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_double_t, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_last_step_output_wall_time_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-last-step-output-wall-time-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->last_step_output_wall_time = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_last_step_output_wall_time_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-last-step-output-wall-time-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double) ((arg1)->last_step_output_wall_time);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_last_step_output_t_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-last-step-output-t-set"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  if (arg1) (arg1)->last_step_output_t = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_last_step_output_t_get (SCM s_0)
{
#define FUNC_NAME "meep-fields-last-step-output-t-get"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (int) ((arg1)->last_step_output_t);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_step (SCM s_0)
{
#define FUNC_NAME "meep-fields-step"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->step();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_round_time (SCM s_0)
{
#define FUNC_NAME "meep-fields-round-time"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double)((meep::fields const *)arg1)->round_time();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_time (SCM s_0)
{
#define FUNC_NAME "meep-fields-time"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double)((meep::fields const *)arg1)->time();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_solve_cw__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-solve-cw"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  int arg3 ;
  std::complex< double > arg4 ;
  int arg5 ;
  std::complex< double > *arg6 = (std::complex< double > *) 0 ;
  double arg7 ;
  int arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[3]);
    arg4 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (std::complex< double > *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_std__complexT_double_t, 6, 0);
  }
  {
    arg7 = (double) scm_to_double(argv[6]);
  }
  {
    arg8 = (int) scm_to_int(argv[7]);
  }
  result = (bool)(arg1)->solve_cw(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_solve_cw__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-solve-cw"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  int arg3 ;
  std::complex< double > arg4 ;
  int arg5 ;
  std::complex< double > *arg6 = (std::complex< double > *) 0 ;
  double arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[3]);
    arg4 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (std::complex< double > *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_std__complexT_double_t, 6, 0);
  }
  {
    arg7 = (double) scm_to_double(argv[6]);
  }
  result = (bool)(arg1)->solve_cw(arg2,arg3,arg4,arg5,arg6,arg7);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_solve_cw__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-solve-cw"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  int arg3 ;
  std::complex< double > arg4 ;
  int arg5 ;
  std::complex< double > *arg6 = (std::complex< double > *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[3]);
    arg4 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (std::complex< double > *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_std__complexT_double_t, 6, 0);
  }
  result = (bool)(arg1)->solve_cw(arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_solve_cw__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-solve-cw"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  int arg3 ;
  std::complex< double > arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[3]);
    arg4 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (bool)(arg1)->solve_cw(arg2,arg3,arg4,arg5);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_solve_cw__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-solve-cw"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  int arg3 ;
  std::complex< double > arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[3]);
    arg4 = std::complex<double>(cnum.re, cnum.im);
  }
  result = (bool)(arg1)->solve_cw(arg2,arg3,arg4);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_solve_cw__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-solve-cw"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  std::complex< double > *arg5 = (std::complex< double > *) 0 ;
  double arg6 ;
  int arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (std::complex< double > *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_std__complexT_double_t, 5, 0);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (int) scm_to_int(argv[6]);
  }
  result = (bool)(arg1)->solve_cw(arg2,arg3,arg4,arg5,arg6,arg7);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_solve_cw__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-solve-cw"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  std::complex< double > *arg5 = (std::complex< double > *) 0 ;
  double arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (std::complex< double > *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_std__complexT_double_t, 5, 0);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  result = (bool)(arg1)->solve_cw(arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_solve_cw__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-solve-cw"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  std::complex< double > *arg5 = (std::complex< double > *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (std::complex< double > *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_std__complexT_double_t, 5, 0);
  }
  result = (bool)(arg1)->solve_cw(arg2,arg3,arg4,arg5);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_solve_cw__SWIG_8 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-solve-cw"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  int arg3 ;
  int arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  result = (bool)(arg1)->solve_cw(arg2,arg3,arg4);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_solve_cw__SWIG_9 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-solve-cw"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  int arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  result = (bool)(arg1)->solve_cw(arg2,arg3);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_solve_cw__SWIG_10 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-solve-cw"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  result = (bool)(arg1)->solve_cw(arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_solve_cw__SWIG_11 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-solve-cw"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (bool)(arg1)->solve_cw();
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_solve_cw(SCM rest)
{
#define FUNC_NAME "meep-fields-solve-cw"
  SCM argv[8];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 8, "meep-fields-solve-cw");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_fields_solve_cw__SWIG_11(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_fields_solve_cw__SWIG_10(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_solve_cw__SWIG_9(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_solve_cw__SWIG_8(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigComplex_Check(argv[3]);
          }
          if (_v) {
            return _wrap_meep_fields_solve_cw__SWIG_4(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_fields_solve_cw__SWIG_7(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigComplex_Check(argv[3]);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_solve_cw__SWIG_3(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_solve_cw__SWIG_6(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigComplex_Check(argv[3]);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_meep_fields_solve_cw__SWIG_2(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_solve_cw__SWIG_5(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigComplex_Check(argv[3]);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_solve_cw__SWIG_1(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigComplex_Check(argv[3]);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_integer_p(argv[7])) && scm_is_true(scm_exact_p(argv[7]))? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_solve_cw__SWIG_0(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-solve-cw", "No matching method for generic function `meep_fields_solve_cw'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_last_source_time (SCM s_0)
{
#define FUNC_NAME "meep-fields-last-source-time"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double)(arg1)->last_source_time();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_point_source__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-point-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  meep::vec *arg7 = 0 ;
  std::complex< double > arg8 ;
  int arg9 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  
  meep::vec vec__arg7 = vector3_to_vec(ctl_convert_vector3_to_c(argv[6]));
  arg7 = &vec__arg7;
  
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[7]);
    arg8 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg9 = (int) scm_to_int(argv[8]);
  }
  (arg1)->add_point_source(arg2,arg3,arg4,arg5,arg6,(meep::vec const &)*arg7,arg8,arg9);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_point_source__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-point-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  meep::vec *arg7 = 0 ;
  std::complex< double > arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  
  meep::vec vec__arg7 = vector3_to_vec(ctl_convert_vector3_to_c(argv[6]));
  arg7 = &vec__arg7;
  
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[7]);
    arg8 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->add_point_source(arg2,arg3,arg4,arg5,arg6,(meep::vec const &)*arg7,arg8);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_point_source__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-point-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  meep::vec *arg7 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  
  meep::vec vec__arg7 = vector3_to_vec(ctl_convert_vector3_to_c(argv[6]));
  arg7 = &vec__arg7;
  
  (arg1)->add_point_source(arg2,arg3,arg4,arg5,arg6,(meep::vec const &)*arg7);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_point_source__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-point-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::src_time *arg3 = 0 ;
  meep::vec *arg4 = 0 ;
  std::complex< double > arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::src_time *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__src_time, 3, 0);
  }
  
  meep::vec vec__arg4 = vector3_to_vec(ctl_convert_vector3_to_c(argv[3]));
  arg4 = &vec__arg4;
  
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[4]);
    arg5 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->add_point_source(arg2,(meep::src_time const &)*arg3,(meep::vec const &)*arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_point_source__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-point-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::src_time *arg3 = 0 ;
  meep::vec *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::src_time *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__src_time, 3, 0);
  }
  
  meep::vec vec__arg4 = vector3_to_vec(ctl_convert_vector3_to_c(argv[3]));
  arg4 = &vec__arg4;
  
  (arg1)->add_point_source(arg2,(meep::src_time const &)*arg3,(meep::vec const &)*arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_point_source(SCM rest)
{
#define FUNC_NAME "meep-fields-add-point-source"
  SCM argv[9];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 9, "meep-fields-add-point-source");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__src_time, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = SwigVector3_Check(argv[3]);
          }
          if (_v) {
            return _wrap_meep_fields_add_point_source__SWIG_4(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__src_time, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = SwigVector3_Check(argv[3]);
          }
          if (_v) {
            {
              _v = SwigComplex_Check(argv[4]);
            }
            if (_v) {
              return _wrap_meep_fields_add_point_source__SWIG_3(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigVector3_Check(argv[6]);
                }
                if (_v) {
                  return _wrap_meep_fields_add_point_source__SWIG_2(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigVector3_Check(argv[6]);
                }
                if (_v) {
                  {
                    _v = SwigComplex_Check(argv[7]);
                  }
                  if (_v) {
                    return _wrap_meep_fields_add_point_source__SWIG_1(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigVector3_Check(argv[6]);
                }
                if (_v) {
                  {
                    _v = SwigComplex_Check(argv[7]);
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_integer_p(argv[8])) && scm_is_true(scm_exact_p(argv[8]))? 1 : 0;
                    }
                    if (_v) {
                      return _wrap_meep_fields_add_point_source__SWIG_0(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-add-point-source", "No matching method for generic function `meep_fields_add_point_source'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_volume_source__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-volume-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::src_time *arg3 = 0 ;
  meep::volume *arg4 = 0 ;
  std::complex< double > *arg5 = (std::complex< double > *) 0 ;
  size_t arg6 ;
  size_t arg7 ;
  size_t arg8 ;
  std::complex< double > arg9 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::src_time *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__src_time, 3, 0);
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
  }
  {
    arg5 = (std::complex< double > *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_std__complexT_double_t, 5, 0);
  }
  {
    arg6 = (size_t) scm_to_ulong(argv[5]);
  }
  {
    arg7 = (size_t) scm_to_ulong(argv[6]);
  }
  {
    arg8 = (size_t) scm_to_ulong(argv[7]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[8]);
    arg9 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->add_volume_source(arg2,(meep::src_time const &)*arg3,(meep::volume const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_volume_source__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-volume-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::src_time *arg3 = 0 ;
  meep::volume *arg4 = 0 ;
  char *arg5 = (char *) 0 ;
  char *arg6 = (char *) 0 ;
  std::complex< double > arg7 ;
  int must_free5 = 0 ;
  int must_free6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::src_time *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__src_time, 3, 0);
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
  }
  {
    arg5 = (char *)SWIG_scm2str(argv[4]);
    must_free5 = 1;
  }
  {
    arg6 = (char *)SWIG_scm2str(argv[5]);
    must_free6 = 1;
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[6]);
    arg7 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->add_volume_source(arg2,(meep::src_time const &)*arg3,(meep::volume const &)*arg4,(char const *)arg5,(char const *)arg6,arg7);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  if (must_free5 && arg5) SWIG_free(arg5);
  if (must_free6 && arg6) SWIG_free(arg6);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_volume_source__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-volume-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::src_time *arg3 = 0 ;
  meep::volume *arg4 = 0 ;
  std::complex< double > (*arg5)(meep::vec const &) = (std::complex< double > (*)(meep::vec const &)) 0 ;
  std::complex< double > arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::src_time *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__src_time, 3, 0);
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
  }
  {
    my_complex_func_scm = argv[4];
    arg5 = my_complex_func;
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[5]);
    arg6 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->add_volume_source(arg2,(meep::src_time const &)*arg3,(meep::volume const &)*arg4,arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_volume_source__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-volume-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::src_time *arg3 = 0 ;
  meep::volume *arg4 = 0 ;
  std::complex< double > (*arg5)(meep::vec const &) = (std::complex< double > (*)(meep::vec const &)) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::src_time *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__src_time, 3, 0);
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
  }
  {
    my_complex_func_scm = argv[4];
    arg5 = my_complex_func;
  }
  (arg1)->add_volume_source(arg2,(meep::src_time const &)*arg3,(meep::volume const &)*arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_volume_source__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-volume-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::src_time *arg3 = 0 ;
  meep::volume *arg4 = 0 ;
  std::complex< double > arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::src_time *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__src_time, 3, 0);
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[4]);
    arg5 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->add_volume_source(arg2,(meep::src_time const &)*arg3,(meep::volume const &)*arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_volume_source__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-volume-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::src_time *arg3 = 0 ;
  meep::volume *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::src_time *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__src_time, 3, 0);
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
  }
  (arg1)->add_volume_source(arg2,(meep::src_time const &)*arg3,(meep::volume const &)*arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_volume_source__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-volume-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::src_time *arg2 = 0 ;
  meep::volume *arg3 = 0 ;
  SwigValueWrapper< meep::gaussianbeam > arg4 ;
  meep::gaussianbeam *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::src_time *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__src_time, 2, 0);
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    argp4 = (meep::gaussianbeam *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__gaussianbeam, 4, 0);
    arg4 = *argp4;
  }
  (arg1)->add_volume_source((meep::src_time const &)*arg2,(meep::volume const &)*arg3,arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_volume_source(SCM rest)
{
#define FUNC_NAME "meep-fields-add-volume-source"
  SCM argv[9];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 9, "meep-fields-add-volume-source");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__src_time, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__gaussianbeam, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_add_volume_source__SWIG_6(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__src_time, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_add_volume_source__SWIG_5(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__src_time, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_NFALSEP(scm_procedure_p(argv[4]));
            }
            if (_v) {
              return _wrap_meep_fields_add_volume_source__SWIG_3(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__src_time, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SwigComplex_Check(argv[4]);
            }
            if (_v) {
              return _wrap_meep_fields_add_volume_source__SWIG_4(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__src_time, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_NFALSEP(scm_procedure_p(argv[4]));
            }
            if (_v) {
              {
                _v = SwigComplex_Check(argv[5]);
              }
              if (_v) {
                return _wrap_meep_fields_add_volume_source__SWIG_2(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__src_time, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_string(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_string(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigComplex_Check(argv[6]);
                }
                if (_v) {
                  return _wrap_meep_fields_add_volume_source__SWIG_1(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__src_time, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_integer_p(argv[7])) && scm_is_true(scm_exact_p(argv[7]))? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = SwigComplex_Check(argv[8]);
                    }
                    if (_v) {
                      return _wrap_meep_fields_add_volume_source__SWIG_0(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-add-volume-source", "No matching method for generic function `meep_fields_add_volume_source'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_is_aniso2d (SCM s_0)
{
#define FUNC_NAME "meep-fields-is-aniso2d"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (bool)(arg1)->is_aniso2d();
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_require_source_components (SCM s_0)
{
#define FUNC_NAME "meep-fields-require-source-components"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->require_source_components();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields__require_component (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-fields--require-component"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  bool arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    arg3 = (bool) scm_is_true(s_2);
  }
  (arg1)->_require_component(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_require_component (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-require-component"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  (arg1)->require_component(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_srcdata (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5)
{
#define FUNC_NAME "meep-fields-add-srcdata"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::sourcedata arg2 ;
  meep::src_time *arg3 = (meep::src_time *) 0 ;
  size_t arg4 ;
  std::complex< double > *arg5 = (std::complex< double > *) 0 ;
  bool arg6 ;
  meep::sourcedata *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::sourcedata *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__sourcedata, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::src_time *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__src_time, 3, 0);
  }
  {
    arg4 = (size_t) scm_to_ulong(s_3);
  }
  {
    arg5 = (std::complex< double > *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_std__complexT_double_t, 5, 0);
  }
  {
    arg6 = (bool) scm_is_true(s_5);
  }
  (arg1)->add_srcdata(arg2,arg3,arg4,arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_register_src_time (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-register-src-time"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::src_time *arg2 = (meep::src_time *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::src_time *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__src_time, 2, 0);
  }
  (arg1)->register_src_time(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_lookup_src_time (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-lookup-src-time"
  meep::fields *arg1 = (meep::fields *) 0 ;
  size_t arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::src_time *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (size_t) scm_to_ulong(s_1);
  }
  result = (meep::src_time *)(arg1)->lookup_src_time(arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__src_time, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eigenmode"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  meep::direction arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  SwigValueWrapper< meep::volume > arg5 ;
  int arg6 ;
  meep::vec *arg7 = 0 ;
  bool arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  double *arg12 = (double *) 0 ;
  void **arg13 = (void **) 0 ;
  meep::diffractedplanewave *arg14 = (meep::diffractedplanewave *) 0 ;
  meep::volume *argp4 ;
  meep::volume *argp5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    argp5 = (meep::volume *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__volume, 5, 0);
    arg5 = *argp5;
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  
  meep::vec vec__arg7 = vector3_to_vec(ctl_convert_vector3_to_c(argv[6]));
  arg7 = &vec__arg7;
  
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  {
    arg9 = (int) scm_to_int(argv[8]);
  }
  {
    arg10 = (double) scm_to_double(argv[9]);
  }
  {
    arg11 = (double) scm_to_double(argv[10]);
  }
  {
    arg12 = (double *)SWIG_MustGetPtr(argv[11], SWIGTYPE_p_double, 12, 0);
  }
  {
    arg13 = (void **)SWIG_MustGetPtr(argv[12], SWIGTYPE_p_p_void, 13, 0);
  }
  {
    arg14 = (meep::diffractedplanewave *)SWIG_MustGetPtr(argv[13], SWIGTYPE_p_meep__diffractedplanewave, 14, 0);
  }
  result = (void *)(arg1)->get_eigenmode(arg2,arg3,arg4,arg5,arg6,(meep::vec const &)*arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eigenmode"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  meep::direction arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  SwigValueWrapper< meep::volume > arg5 ;
  int arg6 ;
  meep::vec *arg7 = 0 ;
  bool arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  double *arg12 = (double *) 0 ;
  void **arg13 = (void **) 0 ;
  meep::volume *argp4 ;
  meep::volume *argp5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    argp5 = (meep::volume *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__volume, 5, 0);
    arg5 = *argp5;
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  
  meep::vec vec__arg7 = vector3_to_vec(ctl_convert_vector3_to_c(argv[6]));
  arg7 = &vec__arg7;
  
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  {
    arg9 = (int) scm_to_int(argv[8]);
  }
  {
    arg10 = (double) scm_to_double(argv[9]);
  }
  {
    arg11 = (double) scm_to_double(argv[10]);
  }
  {
    arg12 = (double *)SWIG_MustGetPtr(argv[11], SWIGTYPE_p_double, 12, 0);
  }
  {
    arg13 = (void **)SWIG_MustGetPtr(argv[12], SWIGTYPE_p_p_void, 13, 0);
  }
  result = (void *)(arg1)->get_eigenmode(arg2,arg3,arg4,arg5,arg6,(meep::vec const &)*arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eigenmode"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  meep::direction arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  SwigValueWrapper< meep::volume > arg5 ;
  int arg6 ;
  meep::vec *arg7 = 0 ;
  bool arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  double *arg12 = (double *) 0 ;
  meep::volume *argp4 ;
  meep::volume *argp5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    argp5 = (meep::volume *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__volume, 5, 0);
    arg5 = *argp5;
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  
  meep::vec vec__arg7 = vector3_to_vec(ctl_convert_vector3_to_c(argv[6]));
  arg7 = &vec__arg7;
  
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  {
    arg9 = (int) scm_to_int(argv[8]);
  }
  {
    arg10 = (double) scm_to_double(argv[9]);
  }
  {
    arg11 = (double) scm_to_double(argv[10]);
  }
  {
    arg12 = (double *)SWIG_MustGetPtr(argv[11], SWIGTYPE_p_double, 12, 0);
  }
  result = (void *)(arg1)->get_eigenmode(arg2,arg3,arg4,arg5,arg6,(meep::vec const &)*arg7,arg8,arg9,arg10,arg11,arg12);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eigenmode"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double arg2 ;
  meep::direction arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  SwigValueWrapper< meep::volume > arg5 ;
  int arg6 ;
  meep::vec *arg7 = 0 ;
  bool arg8 ;
  int arg9 ;
  double arg10 ;
  double arg11 ;
  meep::volume *argp4 ;
  meep::volume *argp5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  void *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    argp5 = (meep::volume *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__volume, 5, 0);
    arg5 = *argp5;
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  
  meep::vec vec__arg7 = vector3_to_vec(ctl_convert_vector3_to_c(argv[6]));
  arg7 = &vec__arg7;
  
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  {
    arg9 = (int) scm_to_int(argv[8]);
  }
  {
    arg10 = (double) scm_to_double(argv[9]);
  }
  {
    arg11 = (double) scm_to_double(argv[10]);
  }
  result = (void *)(arg1)->get_eigenmode(arg2,arg3,arg4,arg5,arg6,(meep::vec const &)*arg7,arg8,arg9,arg10,arg11);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_void, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode(SCM rest)
{
#define FUNC_NAME "meep-fields-get-eigenmode"
  SCM argv[14];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 14, "meep-fields-get-eigenmode");
  if (argc == 11) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigVector3_Check(argv[6]);
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_integer_p(argv[8])) && scm_is_true(scm_exact_p(argv[8]))? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = scm_is_true(scm_real_p(argv[9])) ? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_real_p(argv[10])) ? 1 : 0;
                        }
                        if (_v) {
                          return _wrap_meep_fields_get_eigenmode__SWIG_3(argc,argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigVector3_Check(argv[6]);
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_integer_p(argv[8])) && scm_is_true(scm_exact_p(argv[8]))? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = scm_is_true(scm_real_p(argv[9])) ? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_real_p(argv[10])) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, SWIGTYPE_p_double, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_meep_fields_get_eigenmode__SWIG_2(argc,argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigVector3_Check(argv[6]);
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_integer_p(argv[8])) && scm_is_true(scm_exact_p(argv[8]))? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = scm_is_true(scm_real_p(argv[9])) ? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_real_p(argv[10])) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, SWIGTYPE_p_double, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              void *ptr;
                              int res = SWIG_ConvertPtr(argv[12], &ptr, SWIGTYPE_p_p_void, 0);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_meep_fields_get_eigenmode__SWIG_1(argc,argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigVector3_Check(argv[6]);
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_integer_p(argv[8])) && scm_is_true(scm_exact_p(argv[8]))? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = scm_is_true(scm_real_p(argv[9])) ? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_real_p(argv[10])) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, SWIGTYPE_p_double, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              void *ptr;
                              int res = SWIG_ConvertPtr(argv[12], &ptr, SWIGTYPE_p_p_void, 0);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                void *ptr;
                                int res = SWIG_ConvertPtr(argv[13], &ptr, SWIGTYPE_p_meep__diffractedplanewave, 0);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_meep_fields_get_eigenmode__SWIG_0(argc,argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-get-eigenmode", "No matching method for generic function `meep_fields_get_eigenmode'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_eigenmode_source__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-eigenmode-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::src_time *arg3 = 0 ;
  meep::direction arg4 ;
  meep::volume *arg5 = 0 ;
  meep::volume *arg6 = 0 ;
  int arg7 ;
  meep::vec *arg8 = 0 ;
  bool arg9 ;
  int arg10 ;
  double arg11 ;
  double arg12 ;
  std::complex< double > arg13 ;
  std::complex< double > (*arg14)(meep::vec const &) = (std::complex< double > (*)(meep::vec const &)) 0 ;
  meep::diffractedplanewave *arg15 = (meep::diffractedplanewave *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::src_time *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__src_time, 3, 0);
  }
  {
    arg4 = (meep::direction) scm_to_int(argv[3]); 
  }
  {
    arg5 = (meep::volume *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__volume, 5, 0);
  }
  {
    arg6 = (meep::volume *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__volume, 6, 0);
  }
  {
    arg7 = (int) scm_to_int(argv[6]);
  }
  
  meep::vec vec__arg8 = vector3_to_vec(ctl_convert_vector3_to_c(argv[7]));
  arg8 = &vec__arg8;
  
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  {
    arg10 = (int) scm_to_int(argv[9]);
  }
  {
    arg11 = (double) scm_to_double(argv[10]);
  }
  {
    arg12 = (double) scm_to_double(argv[11]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[12]);
    arg13 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    my_complex_func_scm = argv[13];
    arg14 = my_complex_func;
  }
  {
    arg15 = (meep::diffractedplanewave *)SWIG_MustGetPtr(argv[14], SWIGTYPE_p_meep__diffractedplanewave, 15, 0);
  }
  (arg1)->add_eigenmode_source(arg2,(meep::src_time const &)*arg3,arg4,(meep::volume const &)*arg5,(meep::volume const &)*arg6,arg7,(meep::vec const &)*arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_eigenmode_source__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-eigenmode-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::src_time *arg3 = 0 ;
  meep::direction arg4 ;
  meep::volume *arg5 = 0 ;
  meep::volume *arg6 = 0 ;
  int arg7 ;
  meep::vec *arg8 = 0 ;
  bool arg9 ;
  int arg10 ;
  double arg11 ;
  double arg12 ;
  std::complex< double > arg13 ;
  std::complex< double > (*arg14)(meep::vec const &) = (std::complex< double > (*)(meep::vec const &)) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::src_time *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__src_time, 3, 0);
  }
  {
    arg4 = (meep::direction) scm_to_int(argv[3]); 
  }
  {
    arg5 = (meep::volume *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__volume, 5, 0);
  }
  {
    arg6 = (meep::volume *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__volume, 6, 0);
  }
  {
    arg7 = (int) scm_to_int(argv[6]);
  }
  
  meep::vec vec__arg8 = vector3_to_vec(ctl_convert_vector3_to_c(argv[7]));
  arg8 = &vec__arg8;
  
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  {
    arg10 = (int) scm_to_int(argv[9]);
  }
  {
    arg11 = (double) scm_to_double(argv[10]);
  }
  {
    arg12 = (double) scm_to_double(argv[11]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[12]);
    arg13 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    my_complex_func_scm = argv[13];
    arg14 = my_complex_func;
  }
  (arg1)->add_eigenmode_source(arg2,(meep::src_time const &)*arg3,arg4,(meep::volume const &)*arg5,(meep::volume const &)*arg6,arg7,(meep::vec const &)*arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_eigenmode_source__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-eigenmode-source"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::src_time *arg3 = 0 ;
  meep::direction arg4 ;
  meep::volume *arg5 = 0 ;
  meep::volume *arg6 = 0 ;
  int arg7 ;
  meep::vec *arg8 = 0 ;
  bool arg9 ;
  int arg10 ;
  double arg11 ;
  double arg12 ;
  std::complex< double > arg13 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::src_time *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__src_time, 3, 0);
  }
  {
    arg4 = (meep::direction) scm_to_int(argv[3]); 
  }
  {
    arg5 = (meep::volume *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__volume, 5, 0);
  }
  {
    arg6 = (meep::volume *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__volume, 6, 0);
  }
  {
    arg7 = (int) scm_to_int(argv[6]);
  }
  
  meep::vec vec__arg8 = vector3_to_vec(ctl_convert_vector3_to_c(argv[7]));
  arg8 = &vec__arg8;
  
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  {
    arg10 = (int) scm_to_int(argv[9]);
  }
  {
    arg11 = (double) scm_to_double(argv[10]);
  }
  {
    arg12 = (double) scm_to_double(argv[11]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[12]);
    arg13 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->add_eigenmode_source(arg2,(meep::src_time const &)*arg3,arg4,(meep::volume const &)*arg5,(meep::volume const &)*arg6,arg7,(meep::vec const &)*arg8,arg9,arg10,arg11,arg12,arg13);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_eigenmode_source(SCM rest)
{
#define FUNC_NAME "meep-fields-add-eigenmode-source"
  SCM argv[15];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 15, "meep-fields-add-eigenmode-source");
  if (argc == 13) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__src_time, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SwigVector3_Check(argv[7]);
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = scm_is_true(scm_integer_p(argv[9])) && scm_is_true(scm_exact_p(argv[9]))? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_real_p(argv[10])) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            _v = scm_is_true(scm_real_p(argv[11])) ? 1 : 0;
                          }
                          if (_v) {
                            {
                              _v = SwigComplex_Check(argv[12]);
                            }
                            if (_v) {
                              return _wrap_meep_fields_add_eigenmode_source__SWIG_2(argc,argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__src_time, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SwigVector3_Check(argv[7]);
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = scm_is_true(scm_integer_p(argv[9])) && scm_is_true(scm_exact_p(argv[9]))? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_real_p(argv[10])) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            _v = scm_is_true(scm_real_p(argv[11])) ? 1 : 0;
                          }
                          if (_v) {
                            {
                              _v = SwigComplex_Check(argv[12]);
                            }
                            if (_v) {
                              {
                                _v = SCM_NFALSEP(scm_procedure_p(argv[13]));
                              }
                              if (_v) {
                                return _wrap_meep_fields_add_eigenmode_source__SWIG_1(argc,argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__src_time, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SwigVector3_Check(argv[7]);
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = scm_is_true(scm_integer_p(argv[9])) && scm_is_true(scm_exact_p(argv[9]))? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_real_p(argv[10])) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            _v = scm_is_true(scm_real_p(argv[11])) ? 1 : 0;
                          }
                          if (_v) {
                            {
                              _v = SwigComplex_Check(argv[12]);
                            }
                            if (_v) {
                              {
                                _v = SCM_NFALSEP(scm_procedure_p(argv[13]));
                              }
                              if (_v) {
                                {
                                  void *ptr;
                                  int res = SWIG_ConvertPtr(argv[14], &ptr, SWIGTYPE_p_meep__diffractedplanewave, 0);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_meep_fields_add_eigenmode_source__SWIG_0(argc,argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-add-eigenmode-source", "No matching method for generic function `meep_fields_add_eigenmode_source'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode_coefficients__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eigenmode-coefficients"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg2 ;
  meep::volume *arg3 = 0 ;
  int *arg4 = (int *) 0 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  std::complex< double > *arg9 = (std::complex< double > *) 0 ;
  double *arg10 = (double *) 0 ;
  meep::kpoint_func arg11 = (meep::kpoint_func) 0 ;
  void *arg12 = (void *) 0 ;
  meep::vec *arg13 = (meep::vec *) 0 ;
  meep::vec *arg14 = (meep::vec *) 0 ;
  double *arg15 = (double *) 0 ;
  meep::direction arg16 ;
  meep::diffractedplanewave *arg17 = (meep::diffractedplanewave *) 0 ;
  meep::dft_flux *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_flux *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_flux, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg5 = list_length(argv[3]);
    arg4 = new int[arg5];
    
    for (int i = 0; i < arg5; ++i) {
      arg4[i] = integer_list_ref(argv[3], i);
    }
  }
  {
    arg6 = (int) scm_to_int(argv[4]);
  }
  {
    arg7 = (double) scm_to_double(argv[5]);
  }
  {
    arg8 = (double) scm_to_double(argv[6]);
  }
  scm_t_array_handle coeffs_handle;
  scm_array_get_handle(argv[7], &coeffs_handle);
  arg9 = (std::complex<double>*)scm_array_handle_uniform_writable_elements(&coeffs_handle);
  scm_t_array_handle vgrp_handle;
  scm_array_get_handle(argv[8], &vgrp_handle);
  arg10 = (double*)scm_array_handle_uniform_writable_elements(&vgrp_handle);
  {
    if (SCM_NFALSEP(scm_procedure_p(argv[9]))) {
      arg11 = my_kpoint_func;
      arg12 = (void*)argv[9];
    }
    else {
      arg11 = NULL;
      arg12 = NULL;
    }
  }
  {
    arg13 = (meep::vec *)SWIG_MustGetPtr(argv[10], SWIGTYPE_p_meep__vec, 13, 0);
  }
  {
    arg14 = (meep::vec *)SWIG_MustGetPtr(argv[11], SWIGTYPE_p_meep__vec, 14, 0);
  }
  {
    arg15 = (double *)SWIG_MustGetPtr(argv[12], SWIGTYPE_p_double, 15, 0);
  }
  {
    arg16 = (meep::direction) scm_to_int(argv[13]); 
  }
  {
    arg17 = (meep::diffractedplanewave *)SWIG_MustGetPtr(argv[14], SWIGTYPE_p_meep__diffractedplanewave, 17, 0);
  }
  (arg1)->get_eigenmode_coefficients(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  gswig_result = SCM_UNSPECIFIED;
  
  
  {
    if (arg4) {
      delete[] arg4;
    }
  }
  {
    scm_array_handle_release(&coeffs_handle);
  }
  {
    scm_array_handle_release(&vgrp_handle);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode_coefficients__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eigenmode-coefficients"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg2 ;
  meep::volume *arg3 = 0 ;
  int *arg4 = (int *) 0 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  std::complex< double > *arg9 = (std::complex< double > *) 0 ;
  double *arg10 = (double *) 0 ;
  meep::kpoint_func arg11 = (meep::kpoint_func) 0 ;
  void *arg12 = (void *) 0 ;
  meep::vec *arg13 = (meep::vec *) 0 ;
  meep::vec *arg14 = (meep::vec *) 0 ;
  double *arg15 = (double *) 0 ;
  meep::direction arg16 ;
  meep::dft_flux *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_flux *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_flux, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg5 = list_length(argv[3]);
    arg4 = new int[arg5];
    
    for (int i = 0; i < arg5; ++i) {
      arg4[i] = integer_list_ref(argv[3], i);
    }
  }
  {
    arg6 = (int) scm_to_int(argv[4]);
  }
  {
    arg7 = (double) scm_to_double(argv[5]);
  }
  {
    arg8 = (double) scm_to_double(argv[6]);
  }
  scm_t_array_handle coeffs_handle;
  scm_array_get_handle(argv[7], &coeffs_handle);
  arg9 = (std::complex<double>*)scm_array_handle_uniform_writable_elements(&coeffs_handle);
  scm_t_array_handle vgrp_handle;
  scm_array_get_handle(argv[8], &vgrp_handle);
  arg10 = (double*)scm_array_handle_uniform_writable_elements(&vgrp_handle);
  {
    if (SCM_NFALSEP(scm_procedure_p(argv[9]))) {
      arg11 = my_kpoint_func;
      arg12 = (void*)argv[9];
    }
    else {
      arg11 = NULL;
      arg12 = NULL;
    }
  }
  {
    arg13 = (meep::vec *)SWIG_MustGetPtr(argv[10], SWIGTYPE_p_meep__vec, 13, 0);
  }
  {
    arg14 = (meep::vec *)SWIG_MustGetPtr(argv[11], SWIGTYPE_p_meep__vec, 14, 0);
  }
  {
    arg15 = (double *)SWIG_MustGetPtr(argv[12], SWIGTYPE_p_double, 15, 0);
  }
  {
    arg16 = (meep::direction) scm_to_int(argv[13]); 
  }
  (arg1)->get_eigenmode_coefficients(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  gswig_result = SCM_UNSPECIFIED;
  
  
  {
    if (arg4) {
      delete[] arg4;
    }
  }
  {
    scm_array_handle_release(&coeffs_handle);
  }
  {
    scm_array_handle_release(&vgrp_handle);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode_coefficients__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eigenmode-coefficients"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg2 ;
  meep::volume *arg3 = 0 ;
  int *arg4 = (int *) 0 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  std::complex< double > *arg9 = (std::complex< double > *) 0 ;
  double *arg10 = (double *) 0 ;
  meep::kpoint_func arg11 = (meep::kpoint_func) 0 ;
  void *arg12 = (void *) 0 ;
  meep::vec *arg13 = (meep::vec *) 0 ;
  meep::vec *arg14 = (meep::vec *) 0 ;
  double *arg15 = (double *) 0 ;
  meep::diffractedplanewave *arg16 = (meep::diffractedplanewave *) 0 ;
  meep::dft_flux *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_flux *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_flux, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg5 = list_length(argv[3]);
    arg4 = new int[arg5];
    
    for (int i = 0; i < arg5; ++i) {
      arg4[i] = integer_list_ref(argv[3], i);
    }
  }
  {
    arg6 = (int) scm_to_int(argv[4]);
  }
  {
    arg7 = (double) scm_to_double(argv[5]);
  }
  {
    arg8 = (double) scm_to_double(argv[6]);
  }
  scm_t_array_handle coeffs_handle;
  scm_array_get_handle(argv[7], &coeffs_handle);
  arg9 = (std::complex<double>*)scm_array_handle_uniform_writable_elements(&coeffs_handle);
  scm_t_array_handle vgrp_handle;
  scm_array_get_handle(argv[8], &vgrp_handle);
  arg10 = (double*)scm_array_handle_uniform_writable_elements(&vgrp_handle);
  {
    if (SCM_NFALSEP(scm_procedure_p(argv[9]))) {
      arg11 = my_kpoint_func;
      arg12 = (void*)argv[9];
    }
    else {
      arg11 = NULL;
      arg12 = NULL;
    }
  }
  {
    arg13 = (meep::vec *)SWIG_MustGetPtr(argv[10], SWIGTYPE_p_meep__vec, 13, 0);
  }
  {
    arg14 = (meep::vec *)SWIG_MustGetPtr(argv[11], SWIGTYPE_p_meep__vec, 14, 0);
  }
  {
    arg15 = (double *)SWIG_MustGetPtr(argv[12], SWIGTYPE_p_double, 15, 0);
  }
  {
    arg16 = (meep::diffractedplanewave *)SWIG_MustGetPtr(argv[13], SWIGTYPE_p_meep__diffractedplanewave, 16, 0);
  }
  (arg1)->get_eigenmode_coefficients(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  gswig_result = SCM_UNSPECIFIED;
  
  
  {
    if (arg4) {
      delete[] arg4;
    }
  }
  {
    scm_array_handle_release(&coeffs_handle);
  }
  {
    scm_array_handle_release(&vgrp_handle);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode_coefficients__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eigenmode-coefficients"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg2 ;
  meep::volume *arg3 = 0 ;
  int *arg4 = (int *) 0 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  std::complex< double > *arg9 = (std::complex< double > *) 0 ;
  double *arg10 = (double *) 0 ;
  meep::kpoint_func arg11 = (meep::kpoint_func) 0 ;
  void *arg12 = (void *) 0 ;
  meep::vec *arg13 = (meep::vec *) 0 ;
  meep::vec *arg14 = (meep::vec *) 0 ;
  double *arg15 = (double *) 0 ;
  meep::dft_flux *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_flux *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_flux, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg5 = list_length(argv[3]);
    arg4 = new int[arg5];
    
    for (int i = 0; i < arg5; ++i) {
      arg4[i] = integer_list_ref(argv[3], i);
    }
  }
  {
    arg6 = (int) scm_to_int(argv[4]);
  }
  {
    arg7 = (double) scm_to_double(argv[5]);
  }
  {
    arg8 = (double) scm_to_double(argv[6]);
  }
  scm_t_array_handle coeffs_handle;
  scm_array_get_handle(argv[7], &coeffs_handle);
  arg9 = (std::complex<double>*)scm_array_handle_uniform_writable_elements(&coeffs_handle);
  scm_t_array_handle vgrp_handle;
  scm_array_get_handle(argv[8], &vgrp_handle);
  arg10 = (double*)scm_array_handle_uniform_writable_elements(&vgrp_handle);
  {
    if (SCM_NFALSEP(scm_procedure_p(argv[9]))) {
      arg11 = my_kpoint_func;
      arg12 = (void*)argv[9];
    }
    else {
      arg11 = NULL;
      arg12 = NULL;
    }
  }
  {
    arg13 = (meep::vec *)SWIG_MustGetPtr(argv[10], SWIGTYPE_p_meep__vec, 13, 0);
  }
  {
    arg14 = (meep::vec *)SWIG_MustGetPtr(argv[11], SWIGTYPE_p_meep__vec, 14, 0);
  }
  {
    arg15 = (double *)SWIG_MustGetPtr(argv[12], SWIGTYPE_p_double, 15, 0);
  }
  (arg1)->get_eigenmode_coefficients(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  gswig_result = SCM_UNSPECIFIED;
  
  
  {
    if (arg4) {
      delete[] arg4;
    }
  }
  {
    scm_array_handle_release(&coeffs_handle);
  }
  {
    scm_array_handle_release(&vgrp_handle);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode_coefficients__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eigenmode-coefficients"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg2 ;
  meep::volume *arg3 = 0 ;
  int *arg4 = (int *) 0 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  std::complex< double > *arg9 = (std::complex< double > *) 0 ;
  double *arg10 = (double *) 0 ;
  meep::kpoint_func arg11 = (meep::kpoint_func) 0 ;
  void *arg12 = (void *) 0 ;
  meep::vec *arg13 = (meep::vec *) 0 ;
  meep::vec *arg14 = (meep::vec *) 0 ;
  meep::dft_flux *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_flux *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_flux, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg5 = list_length(argv[3]);
    arg4 = new int[arg5];
    
    for (int i = 0; i < arg5; ++i) {
      arg4[i] = integer_list_ref(argv[3], i);
    }
  }
  {
    arg6 = (int) scm_to_int(argv[4]);
  }
  {
    arg7 = (double) scm_to_double(argv[5]);
  }
  {
    arg8 = (double) scm_to_double(argv[6]);
  }
  scm_t_array_handle coeffs_handle;
  scm_array_get_handle(argv[7], &coeffs_handle);
  arg9 = (std::complex<double>*)scm_array_handle_uniform_writable_elements(&coeffs_handle);
  scm_t_array_handle vgrp_handle;
  scm_array_get_handle(argv[8], &vgrp_handle);
  arg10 = (double*)scm_array_handle_uniform_writable_elements(&vgrp_handle);
  {
    if (SCM_NFALSEP(scm_procedure_p(argv[9]))) {
      arg11 = my_kpoint_func;
      arg12 = (void*)argv[9];
    }
    else {
      arg11 = NULL;
      arg12 = NULL;
    }
  }
  {
    arg13 = (meep::vec *)SWIG_MustGetPtr(argv[10], SWIGTYPE_p_meep__vec, 13, 0);
  }
  {
    arg14 = (meep::vec *)SWIG_MustGetPtr(argv[11], SWIGTYPE_p_meep__vec, 14, 0);
  }
  (arg1)->get_eigenmode_coefficients(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  gswig_result = SCM_UNSPECIFIED;
  
  
  {
    if (arg4) {
      delete[] arg4;
    }
  }
  {
    scm_array_handle_release(&coeffs_handle);
  }
  {
    scm_array_handle_release(&vgrp_handle);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode_coefficients__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eigenmode-coefficients"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg2 ;
  meep::volume *arg3 = 0 ;
  int *arg4 = (int *) 0 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  std::complex< double > *arg9 = (std::complex< double > *) 0 ;
  double *arg10 = (double *) 0 ;
  meep::kpoint_func arg11 = (meep::kpoint_func) 0 ;
  void *arg12 = (void *) 0 ;
  meep::vec *arg13 = (meep::vec *) 0 ;
  meep::dft_flux *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_flux *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_flux, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg5 = list_length(argv[3]);
    arg4 = new int[arg5];
    
    for (int i = 0; i < arg5; ++i) {
      arg4[i] = integer_list_ref(argv[3], i);
    }
  }
  {
    arg6 = (int) scm_to_int(argv[4]);
  }
  {
    arg7 = (double) scm_to_double(argv[5]);
  }
  {
    arg8 = (double) scm_to_double(argv[6]);
  }
  scm_t_array_handle coeffs_handle;
  scm_array_get_handle(argv[7], &coeffs_handle);
  arg9 = (std::complex<double>*)scm_array_handle_uniform_writable_elements(&coeffs_handle);
  scm_t_array_handle vgrp_handle;
  scm_array_get_handle(argv[8], &vgrp_handle);
  arg10 = (double*)scm_array_handle_uniform_writable_elements(&vgrp_handle);
  {
    if (SCM_NFALSEP(scm_procedure_p(argv[9]))) {
      arg11 = my_kpoint_func;
      arg12 = (void*)argv[9];
    }
    else {
      arg11 = NULL;
      arg12 = NULL;
    }
  }
  {
    arg13 = (meep::vec *)SWIG_MustGetPtr(argv[10], SWIGTYPE_p_meep__vec, 13, 0);
  }
  (arg1)->get_eigenmode_coefficients(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  gswig_result = SCM_UNSPECIFIED;
  
  
  {
    if (arg4) {
      delete[] arg4;
    }
  }
  {
    scm_array_handle_release(&coeffs_handle);
  }
  {
    scm_array_handle_release(&vgrp_handle);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode_coefficients__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eigenmode-coefficients"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg2 ;
  meep::volume *arg3 = 0 ;
  int *arg4 = (int *) 0 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  std::complex< double > *arg9 = (std::complex< double > *) 0 ;
  double *arg10 = (double *) 0 ;
  meep::kpoint_func arg11 = (meep::kpoint_func) 0 ;
  void *arg12 = (void *) 0 ;
  meep::dft_flux *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_flux *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_flux, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg5 = list_length(argv[3]);
    arg4 = new int[arg5];
    
    for (int i = 0; i < arg5; ++i) {
      arg4[i] = integer_list_ref(argv[3], i);
    }
  }
  {
    arg6 = (int) scm_to_int(argv[4]);
  }
  {
    arg7 = (double) scm_to_double(argv[5]);
  }
  {
    arg8 = (double) scm_to_double(argv[6]);
  }
  scm_t_array_handle coeffs_handle;
  scm_array_get_handle(argv[7], &coeffs_handle);
  arg9 = (std::complex<double>*)scm_array_handle_uniform_writable_elements(&coeffs_handle);
  scm_t_array_handle vgrp_handle;
  scm_array_get_handle(argv[8], &vgrp_handle);
  arg10 = (double*)scm_array_handle_uniform_writable_elements(&vgrp_handle);
  {
    if (SCM_NFALSEP(scm_procedure_p(argv[9]))) {
      arg11 = my_kpoint_func;
      arg12 = (void*)argv[9];
    }
    else {
      arg11 = NULL;
      arg12 = NULL;
    }
  }
  (arg1)->get_eigenmode_coefficients(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  gswig_result = SCM_UNSPECIFIED;
  
  
  {
    if (arg4) {
      delete[] arg4;
    }
  }
  {
    scm_array_handle_release(&coeffs_handle);
  }
  {
    scm_array_handle_release(&vgrp_handle);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode_coefficients__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eigenmode-coefficients"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg2 ;
  meep::volume *arg3 = 0 ;
  int *arg4 = (int *) 0 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  std::complex< double > *arg9 = (std::complex< double > *) 0 ;
  double *arg10 = (double *) 0 ;
  meep::kpoint_func arg11 = (meep::kpoint_func) 0 ;
  meep::dft_flux *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_flux *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_flux, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg5 = list_length(argv[3]);
    arg4 = new int[arg5];
    
    for (int i = 0; i < arg5; ++i) {
      arg4[i] = integer_list_ref(argv[3], i);
    }
  }
  {
    arg6 = (int) scm_to_int(argv[4]);
  }
  {
    arg7 = (double) scm_to_double(argv[5]);
  }
  {
    arg8 = (double) scm_to_double(argv[6]);
  }
  scm_t_array_handle coeffs_handle;
  scm_array_get_handle(argv[7], &coeffs_handle);
  arg9 = (std::complex<double>*)scm_array_handle_uniform_writable_elements(&coeffs_handle);
  scm_t_array_handle vgrp_handle;
  scm_array_get_handle(argv[8], &vgrp_handle);
  arg10 = (double*)scm_array_handle_uniform_writable_elements(&vgrp_handle);
  {
    arg11 = (meep::kpoint_func)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_f_double_int_p_void__meep__vec, 11, 0);
  }
  (arg1)->get_eigenmode_coefficients(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  gswig_result = SCM_UNSPECIFIED;
  
  
  {
    if (arg4) {
      delete[] arg4;
    }
  }
  {
    scm_array_handle_release(&coeffs_handle);
  }
  {
    scm_array_handle_release(&vgrp_handle);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode_coefficients__SWIG_8 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eigenmode-coefficients"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg2 ;
  meep::volume *arg3 = 0 ;
  int *arg4 = (int *) 0 ;
  int arg5 ;
  int arg6 ;
  double arg7 ;
  double arg8 ;
  std::complex< double > *arg9 = (std::complex< double > *) 0 ;
  double *arg10 = (double *) 0 ;
  meep::dft_flux *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_flux *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_flux, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg5 = list_length(argv[3]);
    arg4 = new int[arg5];
    
    for (int i = 0; i < arg5; ++i) {
      arg4[i] = integer_list_ref(argv[3], i);
    }
  }
  {
    arg6 = (int) scm_to_int(argv[4]);
  }
  {
    arg7 = (double) scm_to_double(argv[5]);
  }
  {
    arg8 = (double) scm_to_double(argv[6]);
  }
  scm_t_array_handle coeffs_handle;
  scm_array_get_handle(argv[7], &coeffs_handle);
  arg9 = (std::complex<double>*)scm_array_handle_uniform_writable_elements(&coeffs_handle);
  scm_t_array_handle vgrp_handle;
  scm_array_get_handle(argv[8], &vgrp_handle);
  arg10 = (double*)scm_array_handle_uniform_writable_elements(&vgrp_handle);
  (arg1)->get_eigenmode_coefficients(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  gswig_result = SCM_UNSPECIFIED;
  
  
  {
    if (arg4) {
      delete[] arg4;
    }
  }
  {
    scm_array_handle_release(&coeffs_handle);
  }
  {
    scm_array_handle_release(&vgrp_handle);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eigenmode_coefficients(SCM rest)
{
#define FUNC_NAME "meep-fields-get-eigenmode-coefficients"
  SCM argv[15];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 15, "meep-fields-get-eigenmode-coefficients");
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_flux, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_meep_fields_get_eigenmode_coefficients__SWIG_8(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_flux, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_f_double_int_p_void__meep__vec, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_meep_fields_get_eigenmode_coefficients__SWIG_7(argc,argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_flux, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_f_double_int_p_void__meep__vec, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        if (argc <= 10) {
                          return _wrap_meep_fields_get_eigenmode_coefficients__SWIG_6(argc,argv);
                        }
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, 0, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_meep_fields_get_eigenmode_coefficients__SWIG_6(argc,argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_flux, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_f_double_int_p_void__meep__vec, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, SWIGTYPE_p_meep__vec, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_meep_fields_get_eigenmode_coefficients__SWIG_5(argc,argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_flux, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_f_double_int_p_void__meep__vec, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, SWIGTYPE_p_meep__vec, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, SWIGTYPE_p_meep__vec, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_meep_fields_get_eigenmode_coefficients__SWIG_4(argc,argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_flux, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_f_double_int_p_void__meep__vec, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, SWIGTYPE_p_meep__vec, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, SWIGTYPE_p_meep__vec, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              void *ptr;
                              int res = SWIG_ConvertPtr(argv[12], &ptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_meep_fields_get_eigenmode_coefficients__SWIG_3(argc,argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_flux, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_f_double_int_p_void__meep__vec, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, SWIGTYPE_p_meep__vec, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, SWIGTYPE_p_meep__vec, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              void *ptr;
                              int res = SWIG_ConvertPtr(argv[12], &ptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                void *ptr;
                                int res = SWIG_ConvertPtr(argv[13], &ptr, SWIGTYPE_p_meep__diffractedplanewave, 0);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_meep_fields_get_eigenmode_coefficients__SWIG_2(argc,argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_flux, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_f_double_int_p_void__meep__vec, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, SWIGTYPE_p_meep__vec, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, SWIGTYPE_p_meep__vec, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              void *ptr;
                              int res = SWIG_ConvertPtr(argv[12], &ptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                _v = scm_is_true(scm_integer_p(argv[13])) && scm_is_true(scm_exact_p(argv[13]))? 1 : 0;
                              }
                              if (_v) {
                                return _wrap_meep_fields_get_eigenmode_coefficients__SWIG_1(argc,argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_flux, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_int, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_real_p(argv[6])) ? 1 : 0;
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_f_double_int_p_void__meep__vec, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, SWIGTYPE_p_meep__vec, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, SWIGTYPE_p_meep__vec, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              void *ptr;
                              int res = SWIG_ConvertPtr(argv[12], &ptr, SWIGTYPE_p_double, 0);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                _v = scm_is_true(scm_integer_p(argv[13])) && scm_is_true(scm_exact_p(argv[13]))? 1 : 0;
                              }
                              if (_v) {
                                {
                                  void *ptr;
                                  int res = SWIG_ConvertPtr(argv[14], &ptr, SWIGTYPE_p_meep__diffractedplanewave, 0);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_meep_fields_get_eigenmode_coefficients__SWIG_0(argc,argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-get-eigenmode-coefficients", "No matching method for generic function `meep_fields_get_eigenmode_coefficients'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_initialize_field (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-fields-initialize-field"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  std::complex< double > (*arg3)(meep::vec const &) = (std::complex< double > (*)(meep::vec const &)) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  {
    my_complex_func_scm = s_2;
    arg3 = my_complex_func;
  }
  (arg1)->initialize_field(arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_initialize_with_nth_te (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-initialize-with-nth-te"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  (arg1)->initialize_with_nth_te(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_initialize_with_nth_tm (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-initialize-with-nth-tm"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  (arg1)->initialize_with_nth_tm(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_initialize_with_n_te (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-initialize-with-n-te"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  (arg1)->initialize_with_n_te(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_initialize_with_n_tm (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-initialize-with-n-tm"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  (arg1)->initialize_with_n_tm(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_phase_in_material (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-fields-phase-in-material"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::structure *arg2 = (meep::structure *) 0 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::structure *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__structure, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  result = (int)(arg1)->phase_in_material((meep::structure const *)arg2,arg3);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_is_phasing (SCM s_0)
{
#define FUNC_NAME "meep-fields-is-phasing"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (int)(arg1)->is_phasing();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_vec2diel_floor (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-fields-vec2diel-floor"
  meep::vec *arg1 = 0 ;
  double arg2 ;
  meep::ivec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  
  meep::vec vec__arg1 = vector3_to_vec(ctl_convert_vector3_to_c(s_0));
  arg1 = &vec__arg1;
  
  {
    arg2 = (double) scm_to_double(s_1);
  }
  {
    arg3 = (meep::ivec *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__ivec, 3, 0);
  }
  result = meep::fields::vec2diel_floor((meep::vec const &)*arg1,arg2,(meep::ivec const &)*arg3);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_vec2diel_ceil (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-fields-vec2diel-ceil"
  meep::vec *arg1 = 0 ;
  double arg2 ;
  meep::ivec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::ivec result;
  
  
  meep::vec vec__arg1 = vector3_to_vec(ctl_convert_vector3_to_c(s_0));
  arg1 = &vec__arg1;
  
  {
    arg2 = (double) scm_to_double(s_1);
  }
  {
    arg3 = (meep::ivec *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__ivec, 3, 0);
  }
  result = meep::fields::vec2diel_ceil((meep::vec const &)*arg1,arg2,(meep::ivec const &)*arg3);
  {
    meep::ivec * resultptr;
    resultptr = new meep::ivec((const meep::ivec &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__ivec, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_loop_in_chunks__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-loop-in-chunks"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::field_chunkloop arg2 = (meep::field_chunkloop) 0 ;
  void *arg3 = (void *) 0 ;
  meep::volume *arg4 = 0 ;
  meep::component arg5 ;
  bool arg6 ;
  bool arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::field_chunkloop)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void, 2, 0);
  }
  {
    arg3 = (void *)SWIG_MustGetPtr(argv[2], NULL, 3, 0);
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
  }
  {
    arg5 = (meep::component) scm_to_int(argv[4]); 
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  (arg1)->loop_in_chunks(arg2,arg3,(meep::volume const &)*arg4,arg5,arg6,arg7);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_loop_in_chunks__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-loop-in-chunks"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::field_chunkloop arg2 = (meep::field_chunkloop) 0 ;
  void *arg3 = (void *) 0 ;
  meep::volume *arg4 = 0 ;
  meep::component arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::field_chunkloop)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void, 2, 0);
  }
  {
    arg3 = (void *)SWIG_MustGetPtr(argv[2], NULL, 3, 0);
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
  }
  {
    arg5 = (meep::component) scm_to_int(argv[4]); 
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  (arg1)->loop_in_chunks(arg2,arg3,(meep::volume const &)*arg4,arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_loop_in_chunks__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-loop-in-chunks"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::field_chunkloop arg2 = (meep::field_chunkloop) 0 ;
  void *arg3 = (void *) 0 ;
  meep::volume *arg4 = 0 ;
  meep::component arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::field_chunkloop)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void, 2, 0);
  }
  {
    arg3 = (void *)SWIG_MustGetPtr(argv[2], NULL, 3, 0);
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
  }
  {
    arg5 = (meep::component) scm_to_int(argv[4]); 
  }
  (arg1)->loop_in_chunks(arg2,arg3,(meep::volume const &)*arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_loop_in_chunks__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-loop-in-chunks"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::field_chunkloop arg2 = (meep::field_chunkloop) 0 ;
  void *arg3 = (void *) 0 ;
  meep::volume *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::field_chunkloop)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void, 2, 0);
  }
  {
    arg3 = (void *)SWIG_MustGetPtr(argv[2], NULL, 3, 0);
  }
  {
    arg4 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 4, 0);
  }
  (arg1)->loop_in_chunks(arg2,arg3,(meep::volume const &)*arg4);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_loop_in_chunks(SCM rest)
{
#define FUNC_NAME "meep-fields-loop-in-chunks"
  SCM argv[7];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 7, "meep-fields-loop-in-chunks");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_loop_in_chunks__SWIG_3(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_loop_in_chunks__SWIG_2(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_loop_in_chunks__SWIG_1(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_loop_in_chunks__SWIG_0(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-loop-in-chunks", "No matching method for generic function `meep_fields_loop_in_chunks'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_integrate__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-integrate"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  meep::component *arg3 = (meep::component *) 0 ;
  meep::field_function arg4 = (meep::field_function) 0 ;
  void *arg5 = (void *) 0 ;
  meep::volume *arg6 = 0 ;
  double *arg7 = (double *) 0 ;
  my_field_func_data data2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = list_length(gh_car(argv[1]));
    arg3 = new meep::component[arg2];
    for (int i = 0; i < arg2; ++i)
    arg3[i] = meep::component(integer_list_ref(gh_car(argv[1]), i));
    data2.nf = arg2;
    data2.func = gh_cdr(argv[1]);
    arg4 = my_field_func;
    arg5 = &data2;
  }
  {
    arg6 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 6, 0);
  }
  {
    arg7 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 7, 0);
  }
  result = (arg1)->integrate(arg2,(meep::component const *)arg3,arg4,arg5,(meep::volume const &)*arg6,arg7);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  {
    if (arg3) delete[] arg3;
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_integrate__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-integrate"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  meep::component *arg3 = (meep::component *) 0 ;
  meep::field_function arg4 = (meep::field_function) 0 ;
  void *arg5 = (void *) 0 ;
  meep::volume *arg6 = 0 ;
  my_field_func_data data2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = list_length(gh_car(argv[1]));
    arg3 = new meep::component[arg2];
    for (int i = 0; i < arg2; ++i)
    arg3[i] = meep::component(integer_list_ref(gh_car(argv[1]), i));
    data2.nf = arg2;
    data2.func = gh_cdr(argv[1]);
    arg4 = my_field_func;
    arg5 = &data2;
  }
  {
    arg6 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 6, 0);
  }
  result = (arg1)->integrate(arg2,(meep::component const *)arg3,arg4,arg5,(meep::volume const &)*arg6);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  {
    if (arg3) delete[] arg3;
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_integrate__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-integrate"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  meep::component *arg3 = (meep::component *) 0 ;
  meep::field_rfunction arg4 = (meep::field_rfunction) 0 ;
  void *arg5 = (void *) 0 ;
  meep::volume *arg6 = 0 ;
  double *arg7 = (double *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (meep::component *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__component, 3, 0);
  }
  {
    arg4 = (meep::field_rfunction)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(argv[4], NULL, 5, 0);
  }
  {
    arg6 = (meep::volume *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__volume, 6, 0);
  }
  {
    arg7 = (double *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_double, 7, 0);
  }
  result = (double)(arg1)->integrate(arg2,(meep::component const *)arg3,arg4,arg5,(meep::volume const &)*arg6,arg7);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_integrate__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-integrate"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  meep::component *arg3 = (meep::component *) 0 ;
  meep::field_rfunction arg4 = (meep::field_rfunction) 0 ;
  void *arg5 = (void *) 0 ;
  meep::volume *arg6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (meep::component *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__component, 3, 0);
  }
  {
    arg4 = (meep::field_rfunction)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(argv[4], NULL, 5, 0);
  }
  {
    arg6 = (meep::volume *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__volume, 6, 0);
  }
  result = (double)(arg1)->integrate(arg2,(meep::component const *)arg3,arg4,arg5,(meep::volume const &)*arg6);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_integrate(SCM rest)
{
#define FUNC_NAME "meep-fields-integrate"
  SCM argv[7];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 7, "meep-fields-integrate");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_pair_p(argv[1])) &&
        SCM_NFALSEP(scm_list_p(gh_car(argv[1]))) &&
        SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[1])));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_integrate__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_pair_p(argv[1])) &&
        SCM_NFALSEP(scm_list_p(gh_car(argv[1]))) &&
        SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[1])));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_integrate__SWIG_0(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__component, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_meep_fields_integrate__SWIG_3(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__component, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_double, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_meep_fields_integrate__SWIG_2(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-integrate", "No matching method for generic function `meep_fields_integrate'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_integrate2__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-integrate2"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::fields *arg2 = 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  int arg5 ;
  meep::component *arg6 = (meep::component *) 0 ;
  meep::field_function arg7 = (meep::field_function) 0 ;
  void *arg8 = (void *) 0 ;
  meep::volume *arg9 = 0 ;
  double *arg10 = (double *) 0 ;
  my_field_func_data data3 ;
  my_field_func_data data30 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = list_length(gh_car(gh_car(argv[2])));
    arg4 = new meep::component[arg3];
    for (int i = 0; i < arg3; ++i)
    arg4[i] = meep::component(integer_list_ref(gh_car(gh_car(argv[2])), i));
    arg5 = list_length(gh_cdr(gh_car(argv[2])));
    arg6 = new meep::component[arg5];
    for (int i = 0; i < arg5; ++i)
    arg6[i] = meep::component(integer_list_ref(gh_cdr(gh_car(argv[2])), i));
    data3.nf = arg3 + arg5;
    data3.func = gh_cdr(argv[2]);
    arg7 = my_field_func;
    arg8 = &data3;
  }
  {
    arg9 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 9, 0);
  }
  {
    arg10 = (double *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_double, 10, 0);
  }
  result = (arg1)->integrate2((meep::fields const &)*arg2,arg3,(meep::component const *)arg4,arg5,(meep::component const *)arg6,arg7,arg8,(meep::volume const &)*arg9,arg10);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  {
    if (arg4) delete[] arg4;
    if (arg6) delete[] arg6;
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_integrate2__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-integrate2"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::fields *arg2 = 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  int arg5 ;
  meep::component *arg6 = (meep::component *) 0 ;
  meep::field_function arg7 = (meep::field_function) 0 ;
  void *arg8 = (void *) 0 ;
  meep::volume *arg9 = 0 ;
  my_field_func_data data3 ;
  my_field_func_data data30 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = list_length(gh_car(gh_car(argv[2])));
    arg4 = new meep::component[arg3];
    for (int i = 0; i < arg3; ++i)
    arg4[i] = meep::component(integer_list_ref(gh_car(gh_car(argv[2])), i));
    arg5 = list_length(gh_cdr(gh_car(argv[2])));
    arg6 = new meep::component[arg5];
    for (int i = 0; i < arg5; ++i)
    arg6[i] = meep::component(integer_list_ref(gh_cdr(gh_car(argv[2])), i));
    data3.nf = arg3 + arg5;
    data3.func = gh_cdr(argv[2]);
    arg7 = my_field_func;
    arg8 = &data3;
  }
  {
    arg9 = (meep::volume *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__volume, 9, 0);
  }
  result = (arg1)->integrate2((meep::fields const &)*arg2,arg3,(meep::component const *)arg4,arg5,(meep::component const *)arg6,arg7,arg8,(meep::volume const &)*arg9);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  {
    if (arg4) delete[] arg4;
    if (arg6) delete[] arg6;
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_integrate2__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-integrate2"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::fields *arg2 = 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  int arg5 ;
  meep::component *arg6 = (meep::component *) 0 ;
  meep::field_rfunction arg7 = (meep::field_rfunction) 0 ;
  void *arg8 = (void *) 0 ;
  meep::volume *arg9 = 0 ;
  double *arg10 = (double *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (meep::component *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__component, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (meep::component *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__component, 6, 0);
  }
  {
    arg7 = (meep::field_rfunction)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 7, 0);
  }
  {
    arg8 = (void *)SWIG_MustGetPtr(argv[7], NULL, 8, 0);
  }
  {
    arg9 = (meep::volume *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_meep__volume, 9, 0);
  }
  {
    arg10 = (double *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_double, 10, 0);
  }
  result = (double)(arg1)->integrate2((meep::fields const &)*arg2,arg3,(meep::component const *)arg4,arg5,(meep::component const *)arg6,arg7,arg8,(meep::volume const &)*arg9,arg10);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_integrate2__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-integrate2"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::fields *arg2 = 0 ;
  int arg3 ;
  meep::component *arg4 = (meep::component *) 0 ;
  int arg5 ;
  meep::component *arg6 = (meep::component *) 0 ;
  meep::field_rfunction arg7 = (meep::field_rfunction) 0 ;
  void *arg8 = (void *) 0 ;
  meep::volume *arg9 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__fields, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (meep::component *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__component, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (meep::component *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__component, 6, 0);
  }
  {
    arg7 = (meep::field_rfunction)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 7, 0);
  }
  {
    arg8 = (void *)SWIG_MustGetPtr(argv[7], NULL, 8, 0);
  }
  {
    arg9 = (meep::volume *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_meep__volume, 9, 0);
  }
  result = (double)(arg1)->integrate2((meep::fields const &)*arg2,arg3,(meep::component const *)arg4,arg5,(meep::component const *)arg6,arg7,arg8,(meep::volume const &)*arg9);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_integrate2(SCM rest)
{
#define FUNC_NAME "meep-fields-integrate2"
  SCM argv[10];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 10, "meep-fields-integrate2");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_NFALSEP(scm_pair_p(argv[2])) &&
          SCM_NFALSEP(scm_pair_p(gh_car(argv[2]))) &&
          SCM_NFALSEP(scm_list_p(gh_car(gh_car(argv[2])))) &&
          SCM_NFALSEP(scm_list_p(gh_cdr(gh_car(argv[2])))) &&
          SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[2])));
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_integrate2__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = SCM_NFALSEP(scm_pair_p(argv[2])) &&
          SCM_NFALSEP(scm_pair_p(gh_car(argv[2]))) &&
          SCM_NFALSEP(scm_list_p(gh_car(gh_car(argv[2])))) &&
          SCM_NFALSEP(scm_list_p(gh_cdr(gh_car(argv[2])))) &&
          SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[2])));
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_double, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_meep_fields_integrate2__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__component, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__component, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, 0, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_meep_fields_integrate2__SWIG_3(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__component, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__component, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, 0, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_meep_fields_integrate2__SWIG_2(argc,argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-integrate2", "No matching method for generic function `meep_fields_integrate2'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_max_abs__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-max-abs"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  meep::component *arg3 = (meep::component *) 0 ;
  meep::field_function arg4 = (meep::field_function) 0 ;
  void *arg5 = (void *) 0 ;
  meep::volume *arg6 = 0 ;
  my_field_func_data data2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = list_length(gh_car(argv[1]));
    arg3 = new meep::component[arg2];
    for (int i = 0; i < arg2; ++i)
    arg3[i] = meep::component(integer_list_ref(gh_car(argv[1]), i));
    data2.nf = arg2;
    data2.func = gh_cdr(argv[1]);
    arg4 = my_field_func;
    arg5 = &data2;
  }
  {
    arg6 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 6, 0);
  }
  result = (double)(arg1)->max_abs(arg2,(meep::component const *)arg3,arg4,arg5,(meep::volume const &)*arg6);
  {
    gswig_result = scm_from_double(result);
  }
  
  {
    if (arg3) delete[] arg3;
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_max_abs__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-max-abs"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  meep::component *arg3 = (meep::component *) 0 ;
  meep::field_rfunction arg4 = (meep::field_rfunction) 0 ;
  void *arg5 = (void *) 0 ;
  meep::volume *arg6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (meep::component *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__component, 3, 0);
  }
  {
    arg4 = (meep::field_rfunction)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 4, 0);
  }
  {
    arg5 = (void *)SWIG_MustGetPtr(argv[4], NULL, 5, 0);
  }
  {
    arg6 = (meep::volume *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__volume, 6, 0);
  }
  result = (double)(arg1)->max_abs(arg2,(meep::component const *)arg3,arg4,arg5,(meep::volume const &)*arg6);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_max_abs__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-max-abs"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  meep::volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  result = (double)(arg1)->max_abs(arg2,(meep::volume const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_max_abs__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-max-abs"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  result = (double)(arg1)->max_abs(arg2,(meep::volume const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_max_abs__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-max-abs"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::derived_component arg2 ;
  meep::volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::derived_component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  result = (double)(arg1)->max_abs(arg2,(meep::volume const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_max_abs(SCM rest)
{
#define FUNC_NAME "meep-fields-max-abs"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "meep-fields-max-abs");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_pair_p(argv[1])) &&
        SCM_NFALSEP(scm_list_p(gh_car(argv[1]))) &&
        SCM_NFALSEP(scm_procedure_p(gh_cdr(argv[1])));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_max_abs__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_max_abs__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_max_abs__SWIG_3(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_max_abs__SWIG_4(argc,argv);
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__component, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_meep_fields_max_abs__SWIG_1(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-max-abs", "No matching method for generic function `meep_fields_max_abs'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  bool arg7 ;
  std::complex< double > arg8 ;
  meep::dft_chunk *arg9 = (meep::dft_chunk *) 0 ;
  bool arg10 ;
  std::complex< double > arg11 ;
  bool arg12 ;
  int arg13 ;
  int arg14 ;
  bool arg15 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[7]);
    arg8 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg9 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_meep__dft_chunk, 9, 0);
  }
  {
    arg10 = (bool) scm_is_true(argv[9]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[10]);
    arg11 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg12 = (bool) scm_is_true(argv[11]);
  }
  {
    arg13 = (int) scm_to_int(argv[12]);
  }
  {
    arg14 = (int) scm_to_int(argv[13]);
  }
  {
    arg15 = (bool) scm_is_true(argv[14]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  bool arg7 ;
  std::complex< double > arg8 ;
  meep::dft_chunk *arg9 = (meep::dft_chunk *) 0 ;
  bool arg10 ;
  std::complex< double > arg11 ;
  bool arg12 ;
  int arg13 ;
  int arg14 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[7]);
    arg8 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg9 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_meep__dft_chunk, 9, 0);
  }
  {
    arg10 = (bool) scm_is_true(argv[9]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[10]);
    arg11 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg12 = (bool) scm_is_true(argv[11]);
  }
  {
    arg13 = (int) scm_to_int(argv[12]);
  }
  {
    arg14 = (int) scm_to_int(argv[13]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  bool arg7 ;
  std::complex< double > arg8 ;
  meep::dft_chunk *arg9 = (meep::dft_chunk *) 0 ;
  bool arg10 ;
  std::complex< double > arg11 ;
  bool arg12 ;
  int arg13 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[7]);
    arg8 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg9 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_meep__dft_chunk, 9, 0);
  }
  {
    arg10 = (bool) scm_is_true(argv[9]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[10]);
    arg11 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg12 = (bool) scm_is_true(argv[11]);
  }
  {
    arg13 = (int) scm_to_int(argv[12]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  bool arg7 ;
  std::complex< double > arg8 ;
  meep::dft_chunk *arg9 = (meep::dft_chunk *) 0 ;
  bool arg10 ;
  std::complex< double > arg11 ;
  bool arg12 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[7]);
    arg8 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg9 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_meep__dft_chunk, 9, 0);
  }
  {
    arg10 = (bool) scm_is_true(argv[9]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[10]);
    arg11 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg12 = (bool) scm_is_true(argv[11]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  bool arg7 ;
  std::complex< double > arg8 ;
  meep::dft_chunk *arg9 = (meep::dft_chunk *) 0 ;
  bool arg10 ;
  std::complex< double > arg11 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[7]);
    arg8 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg9 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_meep__dft_chunk, 9, 0);
  }
  {
    arg10 = (bool) scm_is_true(argv[9]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[10]);
    arg11 = std::complex<double>(cnum.re, cnum.im);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  bool arg7 ;
  std::complex< double > arg8 ;
  meep::dft_chunk *arg9 = (meep::dft_chunk *) 0 ;
  bool arg10 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[7]);
    arg8 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg9 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_meep__dft_chunk, 9, 0);
  }
  {
    arg10 = (bool) scm_is_true(argv[9]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  bool arg7 ;
  std::complex< double > arg8 ;
  meep::dft_chunk *arg9 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[7]);
    arg8 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg9 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_meep__dft_chunk, 9, 0);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  bool arg7 ;
  std::complex< double > arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[7]);
    arg8 = std::complex<double>(cnum.re, cnum.im);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_8 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  bool arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_9 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_10 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  bool arg6 ;
  std::complex< double > arg7 ;
  meep::dft_chunk *arg8 = (meep::dft_chunk *) 0 ;
  bool arg9 ;
  std::complex< double > arg10 ;
  bool arg11 ;
  int arg12 ;
  int arg13 ;
  bool arg14 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[6]);
    arg7 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg8 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__dft_chunk, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[9]);
    arg10 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg11 = (bool) scm_is_true(argv[10]);
  }
  {
    arg12 = (int) scm_to_int(argv[11]);
  }
  {
    arg13 = (int) scm_to_int(argv[12]);
  }
  {
    arg14 = (bool) scm_is_true(argv[13]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_11 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  bool arg6 ;
  std::complex< double > arg7 ;
  meep::dft_chunk *arg8 = (meep::dft_chunk *) 0 ;
  bool arg9 ;
  std::complex< double > arg10 ;
  bool arg11 ;
  int arg12 ;
  int arg13 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[6]);
    arg7 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg8 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__dft_chunk, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[9]);
    arg10 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg11 = (bool) scm_is_true(argv[10]);
  }
  {
    arg12 = (int) scm_to_int(argv[11]);
  }
  {
    arg13 = (int) scm_to_int(argv[12]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_12 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  bool arg6 ;
  std::complex< double > arg7 ;
  meep::dft_chunk *arg8 = (meep::dft_chunk *) 0 ;
  bool arg9 ;
  std::complex< double > arg10 ;
  bool arg11 ;
  int arg12 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[6]);
    arg7 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg8 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__dft_chunk, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[9]);
    arg10 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg11 = (bool) scm_is_true(argv[10]);
  }
  {
    arg12 = (int) scm_to_int(argv[11]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_13 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  bool arg6 ;
  std::complex< double > arg7 ;
  meep::dft_chunk *arg8 = (meep::dft_chunk *) 0 ;
  bool arg9 ;
  std::complex< double > arg10 ;
  bool arg11 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[6]);
    arg7 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg8 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__dft_chunk, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[9]);
    arg10 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg11 = (bool) scm_is_true(argv[10]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_14 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  bool arg6 ;
  std::complex< double > arg7 ;
  meep::dft_chunk *arg8 = (meep::dft_chunk *) 0 ;
  bool arg9 ;
  std::complex< double > arg10 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[6]);
    arg7 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg8 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__dft_chunk, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[9]);
    arg10 = std::complex<double>(cnum.re, cnum.im);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_15 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  bool arg6 ;
  std::complex< double > arg7 ;
  meep::dft_chunk *arg8 = (meep::dft_chunk *) 0 ;
  bool arg9 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[6]);
    arg7 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg8 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__dft_chunk, 8, 0);
  }
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5,arg6,arg7,arg8,arg9);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_16 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  bool arg6 ;
  std::complex< double > arg7 ;
  meep::dft_chunk *arg8 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[6]);
    arg7 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg8 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__dft_chunk, 8, 0);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5,arg6,arg7,arg8);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_17 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  bool arg6 ;
  std::complex< double > arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[6]);
    arg7 = std::complex<double>(cnum.re, cnum.im);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5,arg6,arg7);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_18 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_19 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_20 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  bool arg5 ;
  std::complex< double > arg6 ;
  meep::dft_chunk *arg7 = (meep::dft_chunk *) 0 ;
  bool arg8 ;
  std::complex< double > arg9 ;
  bool arg10 ;
  int arg11 ;
  int arg12 ;
  bool arg13 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[5]);
    arg6 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg7 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__dft_chunk, 7, 0);
  }
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[8]);
    arg9 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg10 = (bool) scm_is_true(argv[9]);
  }
  {
    arg11 = (int) scm_to_int(argv[10]);
  }
  {
    arg12 = (int) scm_to_int(argv[11]);
  }
  {
    arg13 = (bool) scm_is_true(argv[12]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_21 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  bool arg5 ;
  std::complex< double > arg6 ;
  meep::dft_chunk *arg7 = (meep::dft_chunk *) 0 ;
  bool arg8 ;
  std::complex< double > arg9 ;
  bool arg10 ;
  int arg11 ;
  int arg12 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[5]);
    arg6 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg7 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__dft_chunk, 7, 0);
  }
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[8]);
    arg9 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg10 = (bool) scm_is_true(argv[9]);
  }
  {
    arg11 = (int) scm_to_int(argv[10]);
  }
  {
    arg12 = (int) scm_to_int(argv[11]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_22 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  bool arg5 ;
  std::complex< double > arg6 ;
  meep::dft_chunk *arg7 = (meep::dft_chunk *) 0 ;
  bool arg8 ;
  std::complex< double > arg9 ;
  bool arg10 ;
  int arg11 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[5]);
    arg6 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg7 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__dft_chunk, 7, 0);
  }
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[8]);
    arg9 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg10 = (bool) scm_is_true(argv[9]);
  }
  {
    arg11 = (int) scm_to_int(argv[10]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_23 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  bool arg5 ;
  std::complex< double > arg6 ;
  meep::dft_chunk *arg7 = (meep::dft_chunk *) 0 ;
  bool arg8 ;
  std::complex< double > arg9 ;
  bool arg10 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[5]);
    arg6 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg7 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__dft_chunk, 7, 0);
  }
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[8]);
    arg9 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg10 = (bool) scm_is_true(argv[9]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_24 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  bool arg5 ;
  std::complex< double > arg6 ;
  meep::dft_chunk *arg7 = (meep::dft_chunk *) 0 ;
  bool arg8 ;
  std::complex< double > arg9 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[5]);
    arg6 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg7 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__dft_chunk, 7, 0);
  }
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[8]);
    arg9 = std::complex<double>(cnum.re, cnum.im);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_25 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  bool arg5 ;
  std::complex< double > arg6 ;
  meep::dft_chunk *arg7 = (meep::dft_chunk *) 0 ;
  bool arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[5]);
    arg6 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg7 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__dft_chunk, 7, 0);
  }
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4,arg5,arg6,arg7,arg8);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_26 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  bool arg5 ;
  std::complex< double > arg6 ;
  meep::dft_chunk *arg7 = (meep::dft_chunk *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[5]);
    arg6 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg7 = (meep::dft_chunk *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_meep__dft_chunk, 7, 0);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4,arg5,arg6,arg7);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_27 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  bool arg5 ;
  std::complex< double > arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(argv[5]);
    arg6 = std::complex<double>(cnum.re, cnum.im);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_28 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  bool arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_29 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_pt__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-pt"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::vec *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(argv[2]));
  arg3 = &vec__arg3;
  
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft_pt(arg2,(meep::vec const &)*arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_pt__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-pt"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::vec *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(argv[2]));
  arg3 = &vec__arg3;
  
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft_pt(arg2,(meep::vec const &)*arg3,(std::vector< double > const &)*arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_pt(SCM rest)
{
#define FUNC_NAME "meep-fields-add-dft-pt"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "meep-fields-add-dft-pt");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SwigVector3_Check(argv[2]);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_add_dft_pt__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SwigVector3_Check(argv[2]);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft_pt__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-add-dft-pt", "No matching method for generic function `meep_fields_add_dft_pt'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_30 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  bool arg6 ;
  bool arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft((meep::volume_list const *)arg2,arg3,arg4,arg5,arg6,arg7);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_31 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft((meep::volume_list const *)arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_32 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft((meep::volume_list const *)arg2,arg3,arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_33 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  std::vector< double > *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft((meep::volume_list const *)arg2,(std::vector< double > const &)*arg3,arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_34 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  std::vector< double > *arg3 = 0 ;
  bool arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft((meep::volume_list const *)arg2,(std::vector< double > const &)*arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft__SWIG_35 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  std::vector< double > *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::dft_chunk *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  result = (meep::dft_chunk *)(arg1)->add_dft((meep::volume_list const *)arg2,(std::vector< double > const &)*arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__dft_chunk, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft(SCM rest)
{
#define FUNC_NAME "meep-fields-add-dft"
  SCM argv[15];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 15, "meep-fields-add-dft");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_add_dft__SWIG_35(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_add_dft__SWIG_34(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_add_dft__SWIG_29(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft__SWIG_33(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft__SWIG_32(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft__SWIG_28(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft__SWIG_19(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft__SWIG_31(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft__SWIG_18(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SwigComplex_Check(argv[5]);
              }
              if (_v) {
                return _wrap_meep_fields_add_dft__SWIG_27(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft__SWIG_9(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_add_dft__SWIG_30(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SwigComplex_Check(argv[5]);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_meep_fields_add_dft__SWIG_26(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigComplex_Check(argv[6]);
                }
                if (_v) {
                  return _wrap_meep_fields_add_dft__SWIG_17(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_add_dft__SWIG_8(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SwigComplex_Check(argv[5]);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_add_dft__SWIG_25(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigComplex_Check(argv[6]);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_meep_fields_add_dft__SWIG_16(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SwigComplex_Check(argv[7]);
                  }
                  if (_v) {
                    return _wrap_meep_fields_add_dft__SWIG_7(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SwigComplex_Check(argv[5]);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = SwigComplex_Check(argv[8]);
                    }
                    if (_v) {
                      return _wrap_meep_fields_add_dft__SWIG_24(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigComplex_Check(argv[6]);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      return _wrap_meep_fields_add_dft__SWIG_15(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SwigComplex_Check(argv[7]);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_meep_fields_add_dft__SWIG_6(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigComplex_Check(argv[6]);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = SwigComplex_Check(argv[9]);
                      }
                      if (_v) {
                        return _wrap_meep_fields_add_dft__SWIG_14(argc,argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SwigComplex_Check(argv[5]);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = SwigComplex_Check(argv[8]);
                    }
                    if (_v) {
                      {
                        _v = SCM_BOOLP(argv[9]) ? 1 : 0;
                      }
                      if (_v) {
                        return _wrap_meep_fields_add_dft__SWIG_23(argc,argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SwigComplex_Check(argv[7]);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        _v = SCM_BOOLP(argv[9]) ? 1 : 0;
                      }
                      if (_v) {
                        return _wrap_meep_fields_add_dft__SWIG_5(argc,argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigComplex_Check(argv[6]);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = SwigComplex_Check(argv[9]);
                      }
                      if (_v) {
                        {
                          _v = SCM_BOOLP(argv[10]) ? 1 : 0;
                        }
                        if (_v) {
                          return _wrap_meep_fields_add_dft__SWIG_13(argc,argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SwigComplex_Check(argv[5]);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = SwigComplex_Check(argv[8]);
                    }
                    if (_v) {
                      {
                        _v = SCM_BOOLP(argv[9]) ? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_integer_p(argv[10])) && scm_is_true(scm_exact_p(argv[10]))? 1 : 0;
                        }
                        if (_v) {
                          return _wrap_meep_fields_add_dft__SWIG_22(argc,argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SwigComplex_Check(argv[7]);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        _v = SCM_BOOLP(argv[9]) ? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = SwigComplex_Check(argv[10]);
                        }
                        if (_v) {
                          return _wrap_meep_fields_add_dft__SWIG_4(argc,argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SwigComplex_Check(argv[5]);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = SwigComplex_Check(argv[8]);
                    }
                    if (_v) {
                      {
                        _v = SCM_BOOLP(argv[9]) ? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_integer_p(argv[10])) && scm_is_true(scm_exact_p(argv[10]))? 1 : 0;
                        }
                        if (_v) {
                          {
                            _v = scm_is_true(scm_integer_p(argv[11])) && scm_is_true(scm_exact_p(argv[11]))? 1 : 0;
                          }
                          if (_v) {
                            return _wrap_meep_fields_add_dft__SWIG_21(argc,argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigComplex_Check(argv[6]);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = SwigComplex_Check(argv[9]);
                      }
                      if (_v) {
                        {
                          _v = SCM_BOOLP(argv[10]) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            _v = scm_is_true(scm_integer_p(argv[11])) && scm_is_true(scm_exact_p(argv[11]))? 1 : 0;
                          }
                          if (_v) {
                            return _wrap_meep_fields_add_dft__SWIG_12(argc,argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SwigComplex_Check(argv[7]);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        _v = SCM_BOOLP(argv[9]) ? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = SwigComplex_Check(argv[10]);
                        }
                        if (_v) {
                          {
                            _v = SCM_BOOLP(argv[11]) ? 1 : 0;
                          }
                          if (_v) {
                            return _wrap_meep_fields_add_dft__SWIG_3(argc,argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigComplex_Check(argv[6]);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = SwigComplex_Check(argv[9]);
                      }
                      if (_v) {
                        {
                          _v = SCM_BOOLP(argv[10]) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            _v = scm_is_true(scm_integer_p(argv[11])) && scm_is_true(scm_exact_p(argv[11]))? 1 : 0;
                          }
                          if (_v) {
                            {
                              _v = scm_is_true(scm_integer_p(argv[12])) && scm_is_true(scm_exact_p(argv[12]))? 1 : 0;
                            }
                            if (_v) {
                              return _wrap_meep_fields_add_dft__SWIG_11(argc,argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SwigComplex_Check(argv[5]);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = SwigComplex_Check(argv[8]);
                    }
                    if (_v) {
                      {
                        _v = SCM_BOOLP(argv[9]) ? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_integer_p(argv[10])) && scm_is_true(scm_exact_p(argv[10]))? 1 : 0;
                        }
                        if (_v) {
                          {
                            _v = scm_is_true(scm_integer_p(argv[11])) && scm_is_true(scm_exact_p(argv[11]))? 1 : 0;
                          }
                          if (_v) {
                            {
                              _v = SCM_BOOLP(argv[12]) ? 1 : 0;
                            }
                            if (_v) {
                              return _wrap_meep_fields_add_dft__SWIG_20(argc,argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SwigComplex_Check(argv[7]);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        _v = SCM_BOOLP(argv[9]) ? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = SwigComplex_Check(argv[10]);
                        }
                        if (_v) {
                          {
                            _v = SCM_BOOLP(argv[11]) ? 1 : 0;
                          }
                          if (_v) {
                            {
                              _v = scm_is_true(scm_integer_p(argv[12])) && scm_is_true(scm_exact_p(argv[12]))? 1 : 0;
                            }
                            if (_v) {
                              return _wrap_meep_fields_add_dft__SWIG_2(argc,argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SwigComplex_Check(argv[6]);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      {
                        _v = SwigComplex_Check(argv[9]);
                      }
                      if (_v) {
                        {
                          _v = SCM_BOOLP(argv[10]) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            _v = scm_is_true(scm_integer_p(argv[11])) && scm_is_true(scm_exact_p(argv[11]))? 1 : 0;
                          }
                          if (_v) {
                            {
                              _v = scm_is_true(scm_integer_p(argv[12])) && scm_is_true(scm_exact_p(argv[12]))? 1 : 0;
                            }
                            if (_v) {
                              {
                                _v = SCM_BOOLP(argv[13]) ? 1 : 0;
                              }
                              if (_v) {
                                return _wrap_meep_fields_add_dft__SWIG_10(argc,argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SwigComplex_Check(argv[7]);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        _v = SCM_BOOLP(argv[9]) ? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = SwigComplex_Check(argv[10]);
                        }
                        if (_v) {
                          {
                            _v = SCM_BOOLP(argv[11]) ? 1 : 0;
                          }
                          if (_v) {
                            {
                              _v = scm_is_true(scm_integer_p(argv[12])) && scm_is_true(scm_exact_p(argv[12]))? 1 : 0;
                            }
                            if (_v) {
                              {
                                _v = scm_is_true(scm_integer_p(argv[13])) && scm_is_true(scm_exact_p(argv[13]))? 1 : 0;
                              }
                              if (_v) {
                                return _wrap_meep_fields_add_dft__SWIG_1(argc,argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SwigComplex_Check(argv[7]);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_meep__dft_chunk, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        _v = SCM_BOOLP(argv[9]) ? 1 : 0;
                      }
                      if (_v) {
                        {
                          _v = SwigComplex_Check(argv[10]);
                        }
                        if (_v) {
                          {
                            _v = SCM_BOOLP(argv[11]) ? 1 : 0;
                          }
                          if (_v) {
                            {
                              _v = scm_is_true(scm_integer_p(argv[12])) && scm_is_true(scm_exact_p(argv[12]))? 1 : 0;
                            }
                            if (_v) {
                              {
                                _v = scm_is_true(scm_integer_p(argv[13])) && scm_is_true(scm_exact_p(argv[13]))? 1 : 0;
                              }
                              if (_v) {
                                {
                                  _v = SCM_BOOLP(argv[14]) ? 1 : 0;
                                }
                                if (_v) {
                                  return _wrap_meep_fields_add_dft__SWIG_0(argc,argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-add-dft", "No matching method for generic function `meep_fields_add_dft'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_update_dfts (SCM s_0)
{
#define FUNC_NAME "meep-fields-update-dfts"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->update_dfts();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_dft_norm (SCM s_0)
{
#define FUNC_NAME "meep-fields-dft-norm"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double)(arg1)->dft_norm();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_dft_maxfreq (SCM s_0)
{
#define FUNC_NAME "meep-fields-dft-maxfreq"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double)((meep::fields const *)arg1)->dft_maxfreq();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_max_decimation (SCM s_0)
{
#define FUNC_NAME "meep-fields-max-decimation"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (int)((meep::fields const *)arg1)->max_decimation();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_clear_dft_monitors (SCM s_0)
{
#define FUNC_NAME "meep-fields-clear-dft-monitors"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->clear_dft_monitors();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  bool arg5 ;
  bool arg6 ;
  int arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (size_t) scm_to_ulong(argv[3]);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (int) scm_to_int(argv[6]);
  }
  result = (arg1)->add_dft_flux((meep::volume_list const *)arg2,(double const *)arg3,arg4,arg5,arg6,arg7);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  bool arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (size_t) scm_to_ulong(argv[3]);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = (arg1)->add_dft_flux((meep::volume_list const *)arg2,(double const *)arg3,arg4,arg5,arg6);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  bool arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (size_t) scm_to_ulong(argv[3]);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  result = (arg1)->add_dft_flux((meep::volume_list const *)arg2,(double const *)arg3,arg4,arg5);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (size_t) scm_to_ulong(argv[3]);
  }
  result = (arg1)->add_dft_flux((meep::volume_list const *)arg2,(double const *)arg3,arg4);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  std::vector< double > *arg3 = 0 ;
  int arg4 ;
  bool arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = (arg1)->add_dft_flux((meep::volume_list const *)arg2,(std::vector< double > const &)*arg3,arg4,arg5,arg6);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  std::vector< double > *arg3 = 0 ;
  int arg4 ;
  bool arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  result = (arg1)->add_dft_flux((meep::volume_list const *)arg2,(std::vector< double > const &)*arg3,arg4,arg5);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  std::vector< double > *arg3 = 0 ;
  int arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  result = (arg1)->add_dft_flux((meep::volume_list const *)arg2,(std::vector< double > const &)*arg3,arg4);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  std::vector< double > *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  result = (arg1)->add_dft_flux((meep::volume_list const *)arg2,(std::vector< double > const &)*arg3);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_8 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  bool arg6 ;
  bool arg7 ;
  int arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    arg8 = (int) scm_to_int(argv[7]);
  }
  result = (arg1)->add_dft_flux((meep::volume_list const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_9 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  bool arg6 ;
  bool arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  result = (arg1)->add_dft_flux((meep::volume_list const *)arg2,arg3,arg4,arg5,arg6,arg7);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_10 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = (arg1)->add_dft_flux((meep::volume_list const *)arg2,arg3,arg4,arg5,arg6);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_11 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (arg1)->add_dft_flux((meep::volume_list const *)arg2,arg3,arg4,arg5);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_12 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  bool arg7 ;
  bool arg8 ;
  int arg9 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  {
    arg9 = (int) scm_to_int(argv[8]);
  }
  result = (arg1)->add_dft_flux(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_13 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  bool arg7 ;
  bool arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    arg8 = (bool) scm_is_true(argv[7]);
  }
  result = (arg1)->add_dft_flux(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_14 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  bool arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  result = (arg1)->add_dft_flux(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_15 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  result = (arg1)->add_dft_flux(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_16 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  bool arg5 ;
  bool arg6 ;
  int arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (int) scm_to_int(argv[6]);
  }
  result = (arg1)->add_dft_flux(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4,arg5,arg6,arg7);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_17 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  bool arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = (arg1)->add_dft_flux(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4,arg5,arg6);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_18 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  bool arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  result = (arg1)->add_dft_flux(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4,arg5);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_19 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  result = (arg1)->add_dft_flux(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_20 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  bool arg6 ;
  bool arg7 ;
  int arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    arg8 = (int) scm_to_int(argv[7]);
  }
  result = (arg1)->add_dft_flux(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5,arg6,arg7,arg8);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_21 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  bool arg6 ;
  bool arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  result = (arg1)->add_dft_flux(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5,arg6,arg7);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_22 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = (arg1)->add_dft_flux(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5,arg6);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux__SWIG_23 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  result = (arg1)->add_dft_flux(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux(SCM rest)
{
#define FUNC_NAME "meep-fields-add-dft-flux"
  SCM argv[9];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 9, "meep-fields-add-dft-flux");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_add_dft_flux__SWIG_7(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_add_dft_flux__SWIG_6(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_add_dft_flux__SWIG_3(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_add_dft_flux__SWIG_19(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_flux__SWIG_5(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_flux__SWIG_2(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_flux__SWIG_11(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_flux__SWIG_18(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_flux__SWIG_23(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft_flux__SWIG_1(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft_flux__SWIG_4(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft_flux__SWIG_10(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft_flux__SWIG_22(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft_flux__SWIG_17(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft_flux__SWIG_15(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_add_dft_flux__SWIG_0(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_add_dft_flux__SWIG_9(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_add_dft_flux__SWIG_16(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_add_dft_flux__SWIG_21(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_add_dft_flux__SWIG_14(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_integer_p(argv[7])) && scm_is_true(scm_exact_p(argv[7]))? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_add_dft_flux__SWIG_8(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_integer_p(argv[7])) && scm_is_true(scm_exact_p(argv[7]))? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_add_dft_flux__SWIG_20(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_add_dft_flux__SWIG_13(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = scm_is_true(scm_integer_p(argv[8])) && scm_is_true(scm_exact_p(argv[8]))? 1 : 0;
                    }
                    if (_v) {
                      return _wrap_meep_fields_add_dft_flux__SWIG_12(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-add-dft-flux", "No matching method for generic function `meep_fields_add_dft_flux'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux_box__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux-box"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (arg1)->add_dft_flux_box((meep::volume const &)*arg2,arg3,arg4,arg5);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux_box__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux-box"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  result = (arg1)->add_dft_flux_box((meep::volume const &)*arg2,(std::vector< double > const &)*arg3);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux_box(SCM rest)
{
#define FUNC_NAME "meep-fields-add-dft-flux-box"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-fields-add-dft-flux-box");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_add_dft_flux_box__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_flux_box__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-add-dft-flux-box", "No matching method for generic function `meep_fields_add_dft_flux_box'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux_plane__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux-plane"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (arg1)->add_dft_flux_plane((meep::volume const &)*arg2,arg3,arg4,arg5);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux_plane__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-flux-plane"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  std::vector< double > *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  result = (arg1)->add_dft_flux_plane((meep::volume const &)*arg2,(std::vector< double > const &)*arg3);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_flux_plane(SCM rest)
{
#define FUNC_NAME "meep-fields-add-dft-flux-plane"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-fields-add-dft-flux-plane");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_add_dft_flux_plane__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_flux_plane__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-add-dft-flux-plane", "No matching method for generic function `meep_fields_add_dft_flux_plane'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_mode_monitor__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-mode-monitor"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  bool arg7 ;
  int arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  {
    arg8 = (int) scm_to_int(argv[7]);
  }
  result = (arg1)->add_mode_monitor(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_mode_monitor__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-mode-monitor"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  bool arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (bool) scm_is_true(argv[6]);
  }
  result = (arg1)->add_mode_monitor(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_mode_monitor__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-mode-monitor"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  result = (arg1)->add_mode_monitor(arg2,(meep::volume const &)*arg3,arg4,arg5,arg6);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_mode_monitor__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-mode-monitor"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  bool arg5 ;
  int arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  result = (arg1)->add_mode_monitor(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4,arg5,arg6);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_mode_monitor__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-mode-monitor"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  bool arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  {
    arg5 = (bool) scm_is_true(argv[4]);
  }
  result = (arg1)->add_mode_monitor(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4,arg5);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_mode_monitor__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-mode-monitor"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  std::vector< double > *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 4, 0);
  }
  result = (arg1)->add_mode_monitor(arg2,(meep::volume const &)*arg3,(std::vector< double > const &)*arg4);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_mode_monitor__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-mode-monitor"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  bool arg6 ;
  int arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  {
    arg7 = (int) scm_to_int(argv[6]);
  }
  result = (arg1)->add_mode_monitor(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5,arg6,arg7);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_mode_monitor__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-mode-monitor"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = (arg1)->add_mode_monitor(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5,arg6);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_mode_monitor__SWIG_8 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-mode-monitor"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double *arg4 = (double *) 0 ;
  size_t arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_flux > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (size_t) scm_to_ulong(argv[4]);
  }
  result = (arg1)->add_mode_monitor(arg2,(meep::volume const &)*arg3,(double const *)arg4,arg5);
  {
    meep::dft_flux * resultptr;
    resultptr = new meep::dft_flux((const meep::dft_flux &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_flux, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_mode_monitor(SCM rest)
{
#define FUNC_NAME "meep-fields-add-mode-monitor"
  SCM argv[8];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 8, "meep-fields-add-mode-monitor");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_add_mode_monitor__SWIG_5(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_mode_monitor__SWIG_4(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_mode_monitor__SWIG_8(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_mode_monitor__SWIG_3(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_mode_monitor__SWIG_7(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_mode_monitor__SWIG_2(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_add_mode_monitor__SWIG_6(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_add_mode_monitor__SWIG_1(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_integer_p(argv[7])) && scm_is_true(scm_exact_p(argv[7]))? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_add_mode_monitor__SWIG_0(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-add-mode-monitor", "No matching method for generic function `meep_fields_add_mode_monitor'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_fields__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component *arg2 = (meep::component *) 0 ;
  int arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  double arg5 ;
  double arg6 ;
  int arg7 ;
  bool arg8 ;
  int arg9 ;
  bool arg10 ;
  meep::volume *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_fields > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg3 = list_length(argv[1]);
    arg2 = new meep::component[arg3];
    
    for (int i = 0; i < arg3; ++i) {
      arg2[i] = meep::component(integer_list_ref(argv[1], i));
    }
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (double) scm_to_double(argv[3]);
  }
  {
    arg6 = (double) scm_to_double(argv[4]);
  }
  {
    arg7 = (int) scm_to_int(argv[5]);
  }
  {
    arg8 = (bool) scm_is_true(argv[6]);
  }
  {
    arg9 = (int) scm_to_int(argv[7]);
  }
  {
    arg10 = (bool) scm_is_true(argv[8]);
  }
  result = (arg1)->add_dft_fields(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    meep::dft_fields * resultptr;
    resultptr = new meep::dft_fields((const meep::dft_fields &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  {
    if (arg2) {
      delete[] arg2;
    }
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_fields__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component *arg2 = (meep::component *) 0 ;
  int arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  double arg5 ;
  double arg6 ;
  int arg7 ;
  bool arg8 ;
  int arg9 ;
  meep::volume *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_fields > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg3 = list_length(argv[1]);
    arg2 = new meep::component[arg3];
    
    for (int i = 0; i < arg3; ++i) {
      arg2[i] = meep::component(integer_list_ref(argv[1], i));
    }
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (double) scm_to_double(argv[3]);
  }
  {
    arg6 = (double) scm_to_double(argv[4]);
  }
  {
    arg7 = (int) scm_to_int(argv[5]);
  }
  {
    arg8 = (bool) scm_is_true(argv[6]);
  }
  {
    arg9 = (int) scm_to_int(argv[7]);
  }
  result = (arg1)->add_dft_fields(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    meep::dft_fields * resultptr;
    resultptr = new meep::dft_fields((const meep::dft_fields &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  {
    if (arg2) {
      delete[] arg2;
    }
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_fields__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component *arg2 = (meep::component *) 0 ;
  int arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  double arg5 ;
  double arg6 ;
  int arg7 ;
  bool arg8 ;
  meep::volume *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_fields > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg3 = list_length(argv[1]);
    arg2 = new meep::component[arg3];
    
    for (int i = 0; i < arg3; ++i) {
      arg2[i] = meep::component(integer_list_ref(argv[1], i));
    }
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (double) scm_to_double(argv[3]);
  }
  {
    arg6 = (double) scm_to_double(argv[4]);
  }
  {
    arg7 = (int) scm_to_int(argv[5]);
  }
  {
    arg8 = (bool) scm_is_true(argv[6]);
  }
  result = (arg1)->add_dft_fields(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    meep::dft_fields * resultptr;
    resultptr = new meep::dft_fields((const meep::dft_fields &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  {
    if (arg2) {
      delete[] arg2;
    }
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_fields__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component *arg2 = (meep::component *) 0 ;
  int arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  double arg5 ;
  double arg6 ;
  int arg7 ;
  meep::volume *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_fields > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg3 = list_length(argv[1]);
    arg2 = new meep::component[arg3];
    
    for (int i = 0; i < arg3; ++i) {
      arg2[i] = meep::component(integer_list_ref(argv[1], i));
    }
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (double) scm_to_double(argv[3]);
  }
  {
    arg6 = (double) scm_to_double(argv[4]);
  }
  {
    arg7 = (int) scm_to_int(argv[5]);
  }
  result = (arg1)->add_dft_fields(arg2,arg3,arg4,arg5,arg6,arg7);
  {
    meep::dft_fields * resultptr;
    resultptr = new meep::dft_fields((const meep::dft_fields &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  {
    if (arg2) {
      delete[] arg2;
    }
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_fields__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component *arg2 = (meep::component *) 0 ;
  int arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  std::vector< double > *arg5 = 0 ;
  bool arg6 ;
  int arg7 ;
  bool arg8 ;
  meep::volume *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_fields > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg3 = list_length(argv[1]);
    arg2 = new meep::component[arg3];
    
    for (int i = 0; i < arg3; ++i) {
      arg2[i] = meep::component(integer_list_ref(argv[1], i));
    }
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 5, 0);
  }
  {
    arg6 = (bool) scm_is_true(argv[4]);
  }
  {
    arg7 = (int) scm_to_int(argv[5]);
  }
  {
    arg8 = (bool) scm_is_true(argv[6]);
  }
  result = (arg1)->add_dft_fields(arg2,arg3,arg4,(std::vector< double > const &)*arg5,arg6,arg7,arg8);
  {
    meep::dft_fields * resultptr;
    resultptr = new meep::dft_fields((const meep::dft_fields &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  {
    if (arg2) {
      delete[] arg2;
    }
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_fields__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component *arg2 = (meep::component *) 0 ;
  int arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  std::vector< double > *arg5 = 0 ;
  bool arg6 ;
  int arg7 ;
  meep::volume *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_fields > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg3 = list_length(argv[1]);
    arg2 = new meep::component[arg3];
    
    for (int i = 0; i < arg3; ++i) {
      arg2[i] = meep::component(integer_list_ref(argv[1], i));
    }
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 5, 0);
  }
  {
    arg6 = (bool) scm_is_true(argv[4]);
  }
  {
    arg7 = (int) scm_to_int(argv[5]);
  }
  result = (arg1)->add_dft_fields(arg2,arg3,arg4,(std::vector< double > const &)*arg5,arg6,arg7);
  {
    meep::dft_fields * resultptr;
    resultptr = new meep::dft_fields((const meep::dft_fields &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  {
    if (arg2) {
      delete[] arg2;
    }
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_fields__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component *arg2 = (meep::component *) 0 ;
  int arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  std::vector< double > *arg5 = 0 ;
  bool arg6 ;
  meep::volume *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_fields > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg3 = list_length(argv[1]);
    arg2 = new meep::component[arg3];
    
    for (int i = 0; i < arg3; ++i) {
      arg2[i] = meep::component(integer_list_ref(argv[1], i));
    }
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 5, 0);
  }
  {
    arg6 = (bool) scm_is_true(argv[4]);
  }
  result = (arg1)->add_dft_fields(arg2,arg3,arg4,(std::vector< double > const &)*arg5,arg6);
  {
    meep::dft_fields * resultptr;
    resultptr = new meep::dft_fields((const meep::dft_fields &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  {
    if (arg2) {
      delete[] arg2;
    }
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_fields__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component *arg2 = (meep::component *) 0 ;
  int arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  std::vector< double > *arg5 = 0 ;
  meep::volume *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_fields > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg3 = list_length(argv[1]);
    arg2 = new meep::component[arg3];
    
    for (int i = 0; i < arg3; ++i) {
      arg2[i] = meep::component(integer_list_ref(argv[1], i));
    }
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (std::vector< double > *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_std__vectorT_double_t, 5, 0);
  }
  result = (arg1)->add_dft_fields(arg2,arg3,arg4,(std::vector< double > const &)*arg5);
  {
    meep::dft_fields * resultptr;
    resultptr = new meep::dft_fields((const meep::dft_fields &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  {
    if (arg2) {
      delete[] arg2;
    }
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_fields__SWIG_8 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component *arg2 = (meep::component *) 0 ;
  int arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  bool arg7 ;
  int arg8 ;
  bool arg9 ;
  meep::volume *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_fields > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg3 = list_length(argv[1]);
    arg2 = new meep::component[arg3];
    
    for (int i = 0; i < arg3; ++i) {
      arg2[i] = meep::component(integer_list_ref(argv[1], i));
    }
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 5, 0);
  }
  {
    arg6 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg7 = (bool) scm_is_true(argv[5]);
  }
  {
    arg8 = (int) scm_to_int(argv[6]);
  }
  {
    arg9 = (bool) scm_is_true(argv[7]);
  }
  result = (arg1)->add_dft_fields(arg2,arg3,arg4,(double const *)arg5,arg6,arg7,arg8,arg9);
  {
    meep::dft_fields * resultptr;
    resultptr = new meep::dft_fields((const meep::dft_fields &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  {
    if (arg2) {
      delete[] arg2;
    }
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_fields__SWIG_9 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component *arg2 = (meep::component *) 0 ;
  int arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  bool arg7 ;
  int arg8 ;
  meep::volume *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_fields > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg3 = list_length(argv[1]);
    arg2 = new meep::component[arg3];
    
    for (int i = 0; i < arg3; ++i) {
      arg2[i] = meep::component(integer_list_ref(argv[1], i));
    }
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 5, 0);
  }
  {
    arg6 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg7 = (bool) scm_is_true(argv[5]);
  }
  {
    arg8 = (int) scm_to_int(argv[6]);
  }
  result = (arg1)->add_dft_fields(arg2,arg3,arg4,(double const *)arg5,arg6,arg7,arg8);
  {
    meep::dft_fields * resultptr;
    resultptr = new meep::dft_fields((const meep::dft_fields &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  {
    if (arg2) {
      delete[] arg2;
    }
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_fields__SWIG_10 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component *arg2 = (meep::component *) 0 ;
  int arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  bool arg7 ;
  meep::volume *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_fields > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg3 = list_length(argv[1]);
    arg2 = new meep::component[arg3];
    
    for (int i = 0; i < arg3; ++i) {
      arg2[i] = meep::component(integer_list_ref(argv[1], i));
    }
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 5, 0);
  }
  {
    arg6 = (size_t) scm_to_ulong(argv[4]);
  }
  {
    arg7 = (bool) scm_is_true(argv[5]);
  }
  result = (arg1)->add_dft_fields(arg2,arg3,arg4,(double const *)arg5,arg6,arg7);
  {
    meep::dft_fields * resultptr;
    resultptr = new meep::dft_fields((const meep::dft_fields &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  {
    if (arg2) {
      delete[] arg2;
    }
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_fields__SWIG_11 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component *arg2 = (meep::component *) 0 ;
  int arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  double *arg5 = (double *) 0 ;
  size_t arg6 ;
  meep::volume *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_fields > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg3 = list_length(argv[1]);
    arg2 = new meep::component[arg3];
    
    for (int i = 0; i < arg3; ++i) {
      arg2[i] = meep::component(integer_list_ref(argv[1], i));
    }
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (double *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_double, 5, 0);
  }
  {
    arg6 = (size_t) scm_to_ulong(argv[4]);
  }
  result = (arg1)->add_dft_fields(arg2,arg3,arg4,(double const *)arg5,arg6);
  {
    meep::dft_fields * resultptr;
    resultptr = new meep::dft_fields((const meep::dft_fields &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_fields, 1);
  }
  
  {
    if (arg2) {
      delete[] arg2;
    }
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_fields(SCM rest)
{
#define FUNC_NAME "meep-fields-add-dft-fields"
  SCM argv[9];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 9, "meep-fields-add-dft-fields");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_list_p(argv[1]));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_add_dft_fields__SWIG_7(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_list_p(argv[1]));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_fields__SWIG_6(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_list_p(argv[1]));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_fields__SWIG_11(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_list_p(argv[1]));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft_fields__SWIG_5(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_list_p(argv[1]));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft_fields__SWIG_10(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_list_p(argv[1]));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft_fields__SWIG_3(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_list_p(argv[1]));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_add_dft_fields__SWIG_9(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_list_p(argv[1]));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = SCM_BOOLP(argv[4]) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_add_dft_fields__SWIG_4(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_list_p(argv[1]));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_add_dft_fields__SWIG_2(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_list_p(argv[1]));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_double, 0);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  {
                    _v = SCM_BOOLP(argv[7]) ? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_add_dft_fields__SWIG_8(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_list_p(argv[1]));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_integer_p(argv[7])) && scm_is_true(scm_exact_p(argv[7]))? 1 : 0;
                  }
                  if (_v) {
                    return _wrap_meep_fields_add_dft_fields__SWIG_1(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_NFALSEP(scm_list_p(argv[1]));
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = SCM_BOOLP(argv[6]) ? 1 : 0;
                }
                if (_v) {
                  {
                    _v = scm_is_true(scm_integer_p(argv[7])) && scm_is_true(scm_exact_p(argv[7]))? 1 : 0;
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      return _wrap_meep_fields_add_dft_fields__SWIG_0(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-add-dft-fields", "No matching method for generic function `meep_fields_add_dft_fields'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_process_dft_component__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-process-dft-component"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  int arg4 ;
  meep::component arg5 ;
  char *arg6 = (char *) 0 ;
  std::complex< meep::realnum > **arg7 = (std::complex< meep::realnum > **) 0 ;
  int *arg8 = (int *) 0 ;
  size_t *arg9 = (size_t *) 0 ;
  meep::direction *arg10 = (meep::direction *) 0 ;
  void *arg11 = (void *) 0 ;
  void *arg12 = (void *) 0 ;
  meep::component arg13 ;
  bool *arg14 = (bool *) 0 ;
  bool arg15 ;
  int must_free6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (meep::component) scm_to_int(argv[4]); 
  }
  {
    arg6 = (char *)SWIG_scm2str(argv[5]);
    must_free6 = 1;
  }
  {
    arg7 = (std::complex< meep::realnum > **)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (int *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_int, 8, 0);
  }
  {
    arg9 = (size_t *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_size_t, 9, 0);
  }
  {
    arg10 = (meep::direction *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_meep__direction, 10, 0);
  }
  {
    arg11 = (void *)SWIG_MustGetPtr(argv[10], NULL, 11, 0);
  }
  {
    arg12 = (void *)SWIG_MustGetPtr(argv[11], NULL, 12, 0);
  }
  {
    arg13 = (meep::component) scm_to_int(argv[12]); 
  }
  {
    arg14 = (bool *)SWIG_MustGetPtr(argv[13], SWIGTYPE_p_bool, 14, 0);
  }
  {
    arg15 = (bool) scm_is_true(argv[14]);
  }
  result = (arg1)->process_dft_component(arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  if (must_free6 && arg6) SWIG_free(arg6);
  
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_process_dft_component__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-process-dft-component"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  int arg4 ;
  meep::component arg5 ;
  char *arg6 = (char *) 0 ;
  std::complex< meep::realnum > **arg7 = (std::complex< meep::realnum > **) 0 ;
  int *arg8 = (int *) 0 ;
  size_t *arg9 = (size_t *) 0 ;
  meep::direction *arg10 = (meep::direction *) 0 ;
  void *arg11 = (void *) 0 ;
  void *arg12 = (void *) 0 ;
  meep::component arg13 ;
  bool *arg14 = (bool *) 0 ;
  int must_free6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (meep::component) scm_to_int(argv[4]); 
  }
  {
    arg6 = (char *)SWIG_scm2str(argv[5]);
    must_free6 = 1;
  }
  {
    arg7 = (std::complex< meep::realnum > **)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (int *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_int, 8, 0);
  }
  {
    arg9 = (size_t *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_size_t, 9, 0);
  }
  {
    arg10 = (meep::direction *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_meep__direction, 10, 0);
  }
  {
    arg11 = (void *)SWIG_MustGetPtr(argv[10], NULL, 11, 0);
  }
  {
    arg12 = (void *)SWIG_MustGetPtr(argv[11], NULL, 12, 0);
  }
  {
    arg13 = (meep::component) scm_to_int(argv[12]); 
  }
  {
    arg14 = (bool *)SWIG_MustGetPtr(argv[13], SWIGTYPE_p_bool, 14, 0);
  }
  result = (arg1)->process_dft_component(arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  if (must_free6 && arg6) SWIG_free(arg6);
  
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_process_dft_component__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-process-dft-component"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  int arg4 ;
  meep::component arg5 ;
  char *arg6 = (char *) 0 ;
  std::complex< meep::realnum > **arg7 = (std::complex< meep::realnum > **) 0 ;
  int *arg8 = (int *) 0 ;
  size_t *arg9 = (size_t *) 0 ;
  meep::direction *arg10 = (meep::direction *) 0 ;
  void *arg11 = (void *) 0 ;
  void *arg12 = (void *) 0 ;
  meep::component arg13 ;
  int must_free6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (meep::component) scm_to_int(argv[4]); 
  }
  {
    arg6 = (char *)SWIG_scm2str(argv[5]);
    must_free6 = 1;
  }
  {
    arg7 = (std::complex< meep::realnum > **)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (int *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_int, 8, 0);
  }
  {
    arg9 = (size_t *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_size_t, 9, 0);
  }
  {
    arg10 = (meep::direction *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_meep__direction, 10, 0);
  }
  {
    arg11 = (void *)SWIG_MustGetPtr(argv[10], NULL, 11, 0);
  }
  {
    arg12 = (void *)SWIG_MustGetPtr(argv[11], NULL, 12, 0);
  }
  {
    arg13 = (meep::component) scm_to_int(argv[12]); 
  }
  result = (arg1)->process_dft_component(arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  if (must_free6 && arg6) SWIG_free(arg6);
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_process_dft_component__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-process-dft-component"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  int arg4 ;
  meep::component arg5 ;
  char *arg6 = (char *) 0 ;
  std::complex< meep::realnum > **arg7 = (std::complex< meep::realnum > **) 0 ;
  int *arg8 = (int *) 0 ;
  size_t *arg9 = (size_t *) 0 ;
  meep::direction *arg10 = (meep::direction *) 0 ;
  void *arg11 = (void *) 0 ;
  void *arg12 = (void *) 0 ;
  int must_free6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (meep::component) scm_to_int(argv[4]); 
  }
  {
    arg6 = (char *)SWIG_scm2str(argv[5]);
    must_free6 = 1;
  }
  {
    arg7 = (std::complex< meep::realnum > **)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (int *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_int, 8, 0);
  }
  {
    arg9 = (size_t *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_size_t, 9, 0);
  }
  {
    arg10 = (meep::direction *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_meep__direction, 10, 0);
  }
  {
    arg11 = (void *)SWIG_MustGetPtr(argv[10], NULL, 11, 0);
  }
  {
    arg12 = (void *)SWIG_MustGetPtr(argv[11], NULL, 12, 0);
  }
  result = (arg1)->process_dft_component(arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  if (must_free6 && arg6) SWIG_free(arg6);
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_process_dft_component__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-process-dft-component"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  int arg4 ;
  meep::component arg5 ;
  char *arg6 = (char *) 0 ;
  std::complex< meep::realnum > **arg7 = (std::complex< meep::realnum > **) 0 ;
  int *arg8 = (int *) 0 ;
  size_t *arg9 = (size_t *) 0 ;
  meep::direction *arg10 = (meep::direction *) 0 ;
  void *arg11 = (void *) 0 ;
  int must_free6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (meep::component) scm_to_int(argv[4]); 
  }
  {
    arg6 = (char *)SWIG_scm2str(argv[5]);
    must_free6 = 1;
  }
  {
    arg7 = (std::complex< meep::realnum > **)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (int *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_int, 8, 0);
  }
  {
    arg9 = (size_t *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_size_t, 9, 0);
  }
  {
    arg10 = (meep::direction *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_meep__direction, 10, 0);
  }
  {
    arg11 = (void *)SWIG_MustGetPtr(argv[10], NULL, 11, 0);
  }
  result = (arg1)->process_dft_component(arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10,arg11);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  if (must_free6 && arg6) SWIG_free(arg6);
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_process_dft_component__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-process-dft-component"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  int arg4 ;
  meep::component arg5 ;
  char *arg6 = (char *) 0 ;
  std::complex< meep::realnum > **arg7 = (std::complex< meep::realnum > **) 0 ;
  int *arg8 = (int *) 0 ;
  size_t *arg9 = (size_t *) 0 ;
  meep::direction *arg10 = (meep::direction *) 0 ;
  int must_free6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (meep::component) scm_to_int(argv[4]); 
  }
  {
    arg6 = (char *)SWIG_scm2str(argv[5]);
    must_free6 = 1;
  }
  {
    arg7 = (std::complex< meep::realnum > **)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (int *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_int, 8, 0);
  }
  {
    arg9 = (size_t *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_size_t, 9, 0);
  }
  {
    arg10 = (meep::direction *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_meep__direction, 10, 0);
  }
  result = (arg1)->process_dft_component(arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9,arg10);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  if (must_free6 && arg6) SWIG_free(arg6);
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_process_dft_component__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-process-dft-component"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  int arg4 ;
  meep::component arg5 ;
  char *arg6 = (char *) 0 ;
  std::complex< meep::realnum > **arg7 = (std::complex< meep::realnum > **) 0 ;
  int *arg8 = (int *) 0 ;
  size_t *arg9 = (size_t *) 0 ;
  int must_free6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (meep::component) scm_to_int(argv[4]); 
  }
  {
    arg6 = (char *)SWIG_scm2str(argv[5]);
    must_free6 = 1;
  }
  {
    arg7 = (std::complex< meep::realnum > **)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (int *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_int, 8, 0);
  }
  {
    arg9 = (size_t *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_size_t, 9, 0);
  }
  result = (arg1)->process_dft_component(arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8,arg9);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  if (must_free6 && arg6) SWIG_free(arg6);
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_process_dft_component__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-process-dft-component"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  int arg4 ;
  meep::component arg5 ;
  char *arg6 = (char *) 0 ;
  std::complex< meep::realnum > **arg7 = (std::complex< meep::realnum > **) 0 ;
  int *arg8 = (int *) 0 ;
  int must_free6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (meep::component) scm_to_int(argv[4]); 
  }
  {
    arg6 = (char *)SWIG_scm2str(argv[5]);
    must_free6 = 1;
  }
  {
    arg7 = (std::complex< meep::realnum > **)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (int *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_int, 8, 0);
  }
  result = (arg1)->process_dft_component(arg2,arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  if (must_free6 && arg6) SWIG_free(arg6);
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_process_dft_component__SWIG_8 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-process-dft-component"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  int arg4 ;
  meep::component arg5 ;
  char *arg6 = (char *) 0 ;
  std::complex< meep::realnum > **arg7 = (std::complex< meep::realnum > **) 0 ;
  int must_free6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (meep::component) scm_to_int(argv[4]); 
  }
  {
    arg6 = (char *)SWIG_scm2str(argv[5]);
    must_free6 = 1;
  }
  {
    arg7 = (std::complex< meep::realnum > **)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_p_std__complexT_double_t, 7, 0);
  }
  result = (arg1)->process_dft_component(arg2,arg3,arg4,arg5,(char const *)arg6,arg7);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  if (must_free6 && arg6) SWIG_free(arg6);
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_process_dft_component__SWIG_9 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-process-dft-component"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  int arg4 ;
  meep::component arg5 ;
  char *arg6 = (char *) 0 ;
  int must_free6 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (meep::component) scm_to_int(argv[4]); 
  }
  {
    arg6 = (char *)SWIG_scm2str(argv[5]);
    must_free6 = 1;
  }
  result = (arg1)->process_dft_component(arg2,arg3,arg4,arg5,(char const *)arg6);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  if (must_free6 && arg6) SWIG_free(arg6);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_process_dft_component(SCM rest)
{
#define FUNC_NAME "meep-fields-process-dft-component"
  SCM argv[15];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 15, "meep-fields-process-dft-component");
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_string(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_process_dft_component__SWIG_9(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_string(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_meep_fields_process_dft_component__SWIG_8(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_string(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_meep_fields_process_dft_component__SWIG_7(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_string(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_size_t, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_meep_fields_process_dft_component__SWIG_6(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_string(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_size_t, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_meep__direction, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_meep_fields_process_dft_component__SWIG_5(argc,argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_string(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_size_t, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_meep__direction, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, 0, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_meep_fields_process_dft_component__SWIG_4(argc,argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_string(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_size_t, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_meep__direction, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, 0, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, 0, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_meep_fields_process_dft_component__SWIG_3(argc,argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_string(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_size_t, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_meep__direction, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, 0, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, 0, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              _v = scm_is_true(scm_integer_p(argv[12])) && scm_is_true(scm_exact_p(argv[12]))? 1 : 0;
                            }
                            if (_v) {
                              return _wrap_meep_fields_process_dft_component__SWIG_2(argc,argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_string(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_size_t, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_meep__direction, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, 0, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, 0, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              _v = scm_is_true(scm_integer_p(argv[12])) && scm_is_true(scm_exact_p(argv[12]))? 1 : 0;
                            }
                            if (_v) {
                              {
                                void *ptr;
                                int res = SWIG_ConvertPtr(argv[13], &ptr, SWIGTYPE_p_bool, 0);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_meep_fields_process_dft_component__SWIG_1(argc,argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_string(argv[5]) ? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_int, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_size_t, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_meep__direction, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, 0, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, 0, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              _v = scm_is_true(scm_integer_p(argv[12])) && scm_is_true(scm_exact_p(argv[12]))? 1 : 0;
                            }
                            if (_v) {
                              {
                                void *ptr;
                                int res = SWIG_ConvertPtr(argv[13], &ptr, SWIGTYPE_p_bool, 0);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  _v = SCM_BOOLP(argv[14]) ? 1 : 0;
                                }
                                if (_v) {
                                  return _wrap_meep_fields_process_dft_component__SWIG_0(argc,argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-process-dft-component", "No matching method for generic function `meep_fields_process_dft_component'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_dft_components (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4)
{
#define FUNC_NAME "meep-fields-output-dft-components"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  SwigValueWrapper< meep::volume > arg4 ;
  char *arg5 = (char *) 0 ;
  meep::volume *argp4 ;
  int must_free5 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(s_1, SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(s_2);
  }
  {
    argp4 = (meep::volume *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__volume, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (char *)SWIG_scm2str(s_4);
    must_free5 = 1;
  }
  (arg1)->output_dft_components(arg2,arg3,arg4,(char const *)arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  if (must_free5 && arg5) SWIG_free(arg5);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_dft__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg2 ;
  char *arg3 = (char *) 0 ;
  meep::dft_flux *argp2 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_flux *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_flux, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->output_dft(arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_dft__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_force > arg2 ;
  char *arg3 = (char *) 0 ;
  meep::dft_force *argp2 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_force *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_force, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->output_dft(arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_dft__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_near2far > arg2 ;
  char *arg3 = (char *) 0 ;
  meep::dft_near2far *argp2 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_near2far *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_near2far, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->output_dft(arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_dft__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-output-dft"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_fields > arg2 ;
  char *arg3 = (char *) 0 ;
  meep::dft_fields *argp2 ;
  int must_free3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_fields, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (char *)SWIG_scm2str(argv[2]);
    must_free3 = 1;
  }
  (arg1)->output_dft(arg2,(char const *)arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free3 && arg3) SWIG_free(arg3);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_output_dft(SCM rest)
{
#define FUNC_NAME "meep-fields-output-dft"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-fields-output-dft");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_flux, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_output_dft__SWIG_0(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_force, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_output_dft__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_near2far, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_output_dft__SWIG_2(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_string(argv[2]) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_output_dft__SWIG_3(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-output-dft", "No matching method for generic function `meep_fields_output_dft'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_dft_array__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-dft-array"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg2 ;
  meep::component arg3 ;
  int arg4 ;
  int *arg5 = (int *) 0 ;
  size_t *arg6 ;
  meep::dft_flux *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_flux *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_flux, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::component) scm_to_int(argv[2]); 
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (int *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_int, 5, 0);
  }
  {
    arg6 = (size_t *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_size_t, 6, 0);
  }
  result = (std::complex< meep::realnum > *)(arg1)->get_dft_array(arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_dft_array__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-dft-array"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_fields > arg2 ;
  meep::component arg3 ;
  int arg4 ;
  int *arg5 = (int *) 0 ;
  size_t *arg6 ;
  meep::dft_fields *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_fields *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_fields, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::component) scm_to_int(argv[2]); 
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (int *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_int, 5, 0);
  }
  {
    arg6 = (size_t *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_size_t, 6, 0);
  }
  result = (std::complex< meep::realnum > *)(arg1)->get_dft_array(arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_dft_array__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-dft-array"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_force > arg2 ;
  meep::component arg3 ;
  int arg4 ;
  int *arg5 = (int *) 0 ;
  size_t *arg6 ;
  meep::dft_force *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_force *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_force, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::component) scm_to_int(argv[2]); 
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (int *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_int, 5, 0);
  }
  {
    arg6 = (size_t *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_size_t, 6, 0);
  }
  result = (std::complex< meep::realnum > *)(arg1)->get_dft_array(arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_dft_array__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-dft-array"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_near2far > arg2 ;
  meep::component arg3 ;
  int arg4 ;
  int *arg5 = (int *) 0 ;
  size_t *arg6 ;
  meep::dft_near2far *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< meep::realnum > *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_near2far *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__dft_near2far, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::component) scm_to_int(argv[2]); 
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (int *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_int, 5, 0);
  }
  {
    arg6 = (size_t *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_size_t, 6, 0);
  }
  result = (std::complex< meep::realnum > *)(arg1)->get_dft_array(arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_dft_array(SCM rest)
{
#define FUNC_NAME "meep-fields-get-dft-array"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "meep-fields-get-dft-array");
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_flux, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_size_t, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_meep_fields_get_dft_array__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_fields, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_size_t, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_meep_fields_get_dft_array__SWIG_1(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_force, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_size_t, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_meep_fields_get_dft_array__SWIG_2(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__dft_near2far, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_int, 0);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_size_t, 0);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_meep_fields_get_dft_array__SWIG_3(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-get-dft-array", "No matching method for generic function `meep_fields_get_dft_array'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_overlap (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5)
{
#define FUNC_NAME "meep-fields-get-overlap"
  meep::fields *arg1 = (meep::fields *) 0 ;
  void *arg2 = (void *) 0 ;
  void *arg3 = (void *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg4 ;
  int arg5 ;
  std::complex< double > *arg6 ;
  meep::dft_flux *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (void *)SWIG_MustGetPtr(s_1, NULL, 2, 0);
  }
  {
    arg3 = (void *)SWIG_MustGetPtr(s_2, NULL, 3, 0);
  }
  {
    argp4 = (meep::dft_flux *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__dft_flux, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (int) scm_to_int(s_4);
  }
  {
    arg6 = (std::complex< double > *)SWIG_MustGetPtr(s_5, SWIGTYPE_p_std__complexT_double_t, 6, 0);
  }
  (arg1)->get_overlap(arg2,arg3,arg4,arg5,arg6);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_mode_flux_overlap (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4)
{
#define FUNC_NAME "meep-fields-get-mode-flux-overlap"
  meep::fields *arg1 = (meep::fields *) 0 ;
  void *arg2 = (void *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg3 ;
  int arg4 ;
  std::complex< double > *arg5 ;
  meep::dft_flux *argp3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (void *)SWIG_MustGetPtr(s_1, NULL, 2, 0);
  }
  {
    argp3 = (meep::dft_flux *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__dft_flux, 3, 0);
    arg3 = *argp3;
  }
  {
    arg4 = (int) scm_to_int(s_3);
  }
  {
    arg5 = (std::complex< double > *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_std__complexT_double_t, 5, 0);
  }
  (arg1)->get_mode_flux_overlap(arg2,arg3,arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_mode_mode_overlap (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4)
{
#define FUNC_NAME "meep-fields-get-mode-mode-overlap"
  meep::fields *arg1 = (meep::fields *) 0 ;
  void *arg2 = (void *) 0 ;
  void *arg3 = (void *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg4 ;
  std::complex< double > *arg5 ;
  meep::dft_flux *argp4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (void *)SWIG_MustGetPtr(s_1, NULL, 2, 0);
  }
  {
    arg3 = (void *)SWIG_MustGetPtr(s_2, NULL, 3, 0);
  }
  {
    argp4 = (meep::dft_flux *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__dft_flux, 4, 0);
    arg4 = *argp4;
  }
  {
    arg5 = (std::complex< double > *)SWIG_MustGetPtr(s_4, SWIGTYPE_p_std__complexT_double_t, 5, 0);
  }
  (arg1)->get_mode_mode_overlap(arg2,arg3,arg4,arg5);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_energy__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-energy"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_energy > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  result = (arg1)->add_dft_energy((meep::volume_list const *)arg2,arg3,arg4,arg5,arg6);
  {
    meep::dft_energy * resultptr;
    resultptr = new meep::dft_energy((const meep::dft_energy &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_energy, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_energy__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-energy"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_energy > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (arg1)->add_dft_energy((meep::volume_list const *)arg2,arg3,arg4,arg5);
  {
    meep::dft_energy * resultptr;
    resultptr = new meep::dft_energy((const meep::dft_energy &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_energy, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_energy__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-energy"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  std::vector< double > *arg3 = 0 ;
  int arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_energy > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  result = (arg1)->add_dft_energy((meep::volume_list const *)arg2,(std::vector< double > const &)*arg3,arg4);
  {
    meep::dft_energy * resultptr;
    resultptr = new meep::dft_energy((const meep::dft_energy &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_energy, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_energy__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-energy"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  std::vector< double > *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_energy > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  result = (arg1)->add_dft_energy((meep::volume_list const *)arg2,(std::vector< double > const &)*arg3);
  {
    meep::dft_energy * resultptr;
    resultptr = new meep::dft_energy((const meep::dft_energy &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_energy, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_energy__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-energy"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_energy > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (size_t) scm_to_ulong(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (arg1)->add_dft_energy((meep::volume_list const *)arg2,(double const *)arg3,arg4,arg5);
  {
    meep::dft_energy * resultptr;
    resultptr = new meep::dft_energy((const meep::dft_energy &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_energy, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_energy__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-energy"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_energy > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (size_t) scm_to_ulong(argv[3]);
  }
  result = (arg1)->add_dft_energy((meep::volume_list const *)arg2,(double const *)arg3,arg4);
  {
    meep::dft_energy * resultptr;
    resultptr = new meep::dft_energy((const meep::dft_energy &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_energy, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_energy(SCM rest)
{
#define FUNC_NAME "meep-fields-add-dft-energy"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "meep-fields-add-dft-energy");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_add_dft_energy__SWIG_3(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_add_dft_energy__SWIG_2(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_add_dft_energy__SWIG_5(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_energy__SWIG_4(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_energy__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft_energy__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-add-dft-energy", "No matching method for generic function `meep_fields_add_dft_energy'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_force__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-force"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_force > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  result = (arg1)->add_dft_force((meep::volume_list const *)arg2,arg3,arg4,arg5,arg6);
  {
    meep::dft_force * resultptr;
    resultptr = new meep::dft_force((const meep::dft_force &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_force, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_force__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-force"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_force > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (arg1)->add_dft_force((meep::volume_list const *)arg2,arg3,arg4,arg5);
  {
    meep::dft_force * resultptr;
    resultptr = new meep::dft_force((const meep::dft_force &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_force, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_force__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-force"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  std::vector< double > *arg3 = 0 ;
  int arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_force > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  result = (arg1)->add_dft_force((meep::volume_list const *)arg2,(std::vector< double > const &)*arg3,arg4);
  {
    meep::dft_force * resultptr;
    resultptr = new meep::dft_force((const meep::dft_force &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_force, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_force__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-force"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  std::vector< double > *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_force > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  result = (arg1)->add_dft_force((meep::volume_list const *)arg2,(std::vector< double > const &)*arg3);
  {
    meep::dft_force * resultptr;
    resultptr = new meep::dft_force((const meep::dft_force &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_force, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_force__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-force"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_force > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (size_t) scm_to_ulong(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (arg1)->add_dft_force((meep::volume_list const *)arg2,(double const *)arg3,arg4,arg5);
  {
    meep::dft_force * resultptr;
    resultptr = new meep::dft_force((const meep::dft_force &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_force, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_force__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-force"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_force > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (size_t) scm_to_ulong(argv[3]);
  }
  result = (arg1)->add_dft_force((meep::volume_list const *)arg2,(double const *)arg3,arg4);
  {
    meep::dft_force * resultptr;
    resultptr = new meep::dft_force((const meep::dft_force &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_force, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_force(SCM rest)
{
#define FUNC_NAME "meep-fields-add-dft-force"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "meep-fields-add-dft-force");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_add_dft_force__SWIG_3(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_add_dft_force__SWIG_2(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_add_dft_force__SWIG_5(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_force__SWIG_4(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_force__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft_force__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-add-dft-force", "No matching method for generic function `meep_fields_add_dft_force'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_near2far__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-near2far"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_near2far > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (int) scm_to_int(argv[6]);
  }
  result = (arg1)->add_dft_near2far((meep::volume_list const *)arg2,arg3,arg4,arg5,arg6,arg7);
  {
    meep::dft_near2far * resultptr;
    resultptr = new meep::dft_near2far((const meep::dft_near2far &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_near2far, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_near2far__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-near2far"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  int arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_near2far > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  result = (arg1)->add_dft_near2far((meep::volume_list const *)arg2,arg3,arg4,arg5,arg6);
  {
    meep::dft_near2far * resultptr;
    resultptr = new meep::dft_near2far((const meep::dft_near2far &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_near2far, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_near2far__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-near2far"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_near2far > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (arg1)->add_dft_near2far((meep::volume_list const *)arg2,arg3,arg4,arg5);
  {
    meep::dft_near2far * resultptr;
    resultptr = new meep::dft_near2far((const meep::dft_near2far &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_near2far, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_near2far__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-near2far"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  std::vector< double > *arg3 = 0 ;
  int arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_near2far > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (arg1)->add_dft_near2far((meep::volume_list const *)arg2,(std::vector< double > const &)*arg3,arg4,arg5);
  {
    meep::dft_near2far * resultptr;
    resultptr = new meep::dft_near2far((const meep::dft_near2far &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_near2far, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_near2far__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-near2far"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  std::vector< double > *arg3 = 0 ;
  int arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_near2far > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  {
    arg4 = (int) scm_to_int(argv[3]);
  }
  result = (arg1)->add_dft_near2far((meep::volume_list const *)arg2,(std::vector< double > const &)*arg3,arg4);
  {
    meep::dft_near2far * resultptr;
    resultptr = new meep::dft_near2far((const meep::dft_near2far &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_near2far, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_near2far__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-near2far"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  std::vector< double > *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_near2far > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (std::vector< double > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__vectorT_double_t, 3, 0);
  }
  result = (arg1)->add_dft_near2far((meep::volume_list const *)arg2,(std::vector< double > const &)*arg3);
  {
    meep::dft_near2far * resultptr;
    resultptr = new meep::dft_near2far((const meep::dft_near2far &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_near2far, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_near2far__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-near2far"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  int arg5 ;
  int arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_near2far > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (size_t) scm_to_ulong(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  result = (arg1)->add_dft_near2far((meep::volume_list const *)arg2,(double const *)arg3,arg4,arg5,arg6);
  {
    meep::dft_near2far * resultptr;
    resultptr = new meep::dft_near2far((const meep::dft_near2far &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_near2far, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_near2far__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-near2far"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  int arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_near2far > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (size_t) scm_to_ulong(argv[3]);
  }
  {
    arg5 = (int) scm_to_int(argv[4]);
  }
  result = (arg1)->add_dft_near2far((meep::volume_list const *)arg2,(double const *)arg3,arg4,arg5);
  {
    meep::dft_near2far * resultptr;
    resultptr = new meep::dft_near2far((const meep::dft_near2far &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_near2far, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_near2far__SWIG_8 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-dft-near2far"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume_list *arg2 = (meep::volume_list *) 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  SwigValueWrapper< meep::dft_near2far > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume_list *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume_list, 2, 0);
  }
  {
    arg3 = (double *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_double, 3, 0);
  }
  {
    arg4 = (size_t) scm_to_ulong(argv[3]);
  }
  result = (arg1)->add_dft_near2far((meep::volume_list const *)arg2,(double const *)arg3,arg4);
  {
    meep::dft_near2far * resultptr;
    resultptr = new meep::dft_near2far((const meep::dft_near2far &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_meep__dft_near2far, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_dft_near2far(SCM rest)
{
#define FUNC_NAME "meep-fields-add-dft-near2far"
  SCM argv[7];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 7, "meep-fields-add-dft-near2far");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_add_dft_near2far__SWIG_5(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_add_dft_near2far__SWIG_4(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_add_dft_near2far__SWIG_8(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_near2far__SWIG_3(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_near2far__SWIG_7(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_add_dft_near2far__SWIG_2(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_double, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft_near2far__SWIG_6(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_add_dft_near2far__SWIG_1(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume_list, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_integer_p(argv[4])) && scm_is_true(scm_exact_p(argv[4]))? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  return _wrap_meep_fields_add_dft_near2far__SWIG_0(argc,argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-add-dft-near2far", "No matching method for generic function `meep_fields_add_dft_near2far'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_chi1inv__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-chi1inv"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::vec *arg4 = 0 ;
  double arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  
  meep::vec vec__arg4 = vector3_to_vec(ctl_convert_vector3_to_c(argv[3]));
  arg4 = &vec__arg4;
  
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = ((meep::fields const *)arg1)->get_chi1inv(arg2,arg3,(meep::vec const &)*arg4,arg5,arg6);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_chi1inv__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-chi1inv"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::vec *arg4 = 0 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  
  meep::vec vec__arg4 = vector3_to_vec(ctl_convert_vector3_to_c(argv[3]));
  arg4 = &vec__arg4;
  
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = ((meep::fields const *)arg1)->get_chi1inv(arg2,arg3,(meep::vec const &)*arg4,arg5);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_chi1inv__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-chi1inv"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::vec *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  
  meep::vec vec__arg4 = vector3_to_vec(ctl_convert_vector3_to_c(argv[3]));
  arg4 = &vec__arg4;
  
  result = ((meep::fields const *)arg1)->get_chi1inv(arg2,arg3,(meep::vec const &)*arg4);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_inveps__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-inveps"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::vec *arg4 = 0 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  
  meep::vec vec__arg4 = vector3_to_vec(ctl_convert_vector3_to_c(argv[3]));
  arg4 = &vec__arg4;
  
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = ((meep::fields const *)arg1)->get_inveps(arg2,arg3,(meep::vec const &)*arg4,arg5);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_inveps__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-inveps"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::vec *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  
  meep::vec vec__arg4 = vector3_to_vec(ctl_convert_vector3_to_c(argv[3]));
  arg4 = &vec__arg4;
  
  result = ((meep::fields const *)arg1)->get_inveps(arg2,arg3,(meep::vec const &)*arg4);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_inveps(SCM rest)
{
#define FUNC_NAME "meep-fields-get-inveps"
  SCM argv[5];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 5, "meep-fields-get-inveps");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigVector3_Check(argv[3]);
          }
          if (_v) {
            return _wrap_meep_fields_get_inveps__SWIG_1(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigVector3_Check(argv[3]);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_get_inveps__SWIG_0(argc,argv);
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-get-inveps", "No matching method for generic function `meep_fields_get_inveps'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eps__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eps"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::vec *arg2 = 0 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  result = ((meep::fields const *)arg1)->get_eps((meep::vec const &)*arg2,arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eps__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-eps"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  result = ((meep::fields const *)arg1)->get_eps((meep::vec const &)*arg2);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_eps(SCM rest)
{
#define FUNC_NAME "meep-fields-get-eps"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-fields-get-eps");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        return _wrap_meep_fields_get_eps__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_get_eps__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-get-eps", "No matching method for generic function `meep_fields_get_eps'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_mu__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-mu"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::vec *arg2 = 0 ;
  double arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  result = ((meep::fields const *)arg1)->get_mu((meep::vec const &)*arg2,arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_mu__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-mu"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  result = ((meep::fields const *)arg1)->get_mu((meep::vec const &)*arg2);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_mu(SCM rest)
{
#define FUNC_NAME "meep-fields-get-mu"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-fields-get-mu");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        return _wrap_meep_fields_get_mu__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          return _wrap_meep_fields_get_mu__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-get-mu", "No matching method for generic function `meep_fields_get_mu'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_point (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-fields-get-point"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::monitor_point *arg2 = (meep::monitor_point *) 0 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::monitor_point *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__monitor_point, 2, 0);
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(s_2));
  arg3 = &vec__arg3;
  
  ((meep::fields const *)arg1)->get_point(arg2,(meep::vec const &)*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_new_point__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-new-point"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::vec *arg2 = 0 ;
  meep::monitor_point *arg3 = (meep::monitor_point *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::monitor_point *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  {
    arg3 = (meep::monitor_point *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__monitor_point, 3, 0);
  }
  result = (meep::monitor_point *)((meep::fields const *)arg1)->get_new_point((meep::vec const &)*arg2,arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__monitor_point, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_new_point__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-new-point"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::monitor_point *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  result = (meep::monitor_point *)((meep::fields const *)arg1)->get_new_point((meep::vec const &)*arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__monitor_point, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_new_point(SCM rest)
{
#define FUNC_NAME "meep-fields-get-new-point"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-fields-get-new-point");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        return _wrap_meep_fields_get_new_point__SWIG_1(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__monitor_point, 0);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_get_new_point__SWIG_0(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-get-new-point", "No matching method for generic function `meep_fields_get_new_point'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_field__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-field"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  meep::vec *arg3 = 0 ;
  bool arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(argv[2]));
  arg3 = &vec__arg3;
  
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  result = ((meep::fields const *)arg1)->get_field(arg2,(meep::vec const &)*arg3,arg4);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_field__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-field"
  meep::fields *arg1 = (meep::fields *) 0 ;
  int arg2 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(argv[2]));
  arg3 = &vec__arg3;
  
  result = ((meep::fields const *)arg1)->get_field(arg2,(meep::vec const &)*arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_field__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-field"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::vec *arg3 = 0 ;
  bool arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(argv[2]));
  arg3 = &vec__arg3;
  
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  result = ((meep::fields const *)arg1)->get_field(arg2,(meep::vec const &)*arg3,arg4);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_field__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-field"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(argv[2]));
  arg3 = &vec__arg3;
  
  result = ((meep::fields const *)arg1)->get_field(arg2,(meep::vec const &)*arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_field__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-field"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::derived_component arg2 ;
  meep::vec *arg3 = 0 ;
  bool arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::derived_component) scm_to_int(argv[1]); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(argv[2]));
  arg3 = &vec__arg3;
  
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  result = (double)((meep::fields const *)arg1)->get_field(arg2,(meep::vec const &)*arg3,arg4);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_field__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-field"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::derived_component arg2 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::derived_component) scm_to_int(argv[1]); 
  }
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(argv[2]));
  arg3 = &vec__arg3;
  
  result = (double)((meep::fields const *)arg1)->get_field(arg2,(meep::vec const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_dft_monitor_size (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-fields-dft-monitor-size"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_fields > arg2 ;
  meep::volume *arg3 = 0 ;
  meep::component arg4 ;
  meep::dft_fields *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::vector< size_t > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_fields *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_fields, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (meep::component) scm_to_int(s_3); 
  }
  result = (arg1)->dft_monitor_size(arg2,(meep::volume const &)*arg3,arg4);
  {
    std::vector< size_t > * resultptr;
    resultptr = new std::vector< size_t >((const std::vector< size_t > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__vectorT_size_t_t, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_dft_component_dims__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-dft-component-dims"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  meep::component arg4 ;
  meep::ivec *arg5 = 0 ;
  meep::ivec *arg6 = 0 ;
  size_t *arg7 = 0 ;
  size_t *arg8 = 0 ;
  int *arg9 = 0 ;
  meep::direction *arg10 = (meep::direction *) 0 ;
  size_t *arg11 = (size_t *) 0 ;
  int *arg12 = (int *) 0 ;
  size_t *arg13 = (size_t *) 0 ;
  meep::direction *arg14 = (meep::direction *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (meep::component) scm_to_int(argv[3]); 
  }
  {
    arg5 = (meep::ivec *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__ivec, 5, 0);
  }
  {
    arg6 = (meep::ivec *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__ivec, 6, 0);
  }
  {
    arg7 = (size_t *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_size_t, 7, 0);
  }
  {
    arg8 = (size_t *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_size_t, 8, 0);
  }
  {
    arg9 = (int *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_int, 9, 0);
  }
  {
    arg10 = (meep::direction *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_meep__direction, 10, 0);
  }
  {
    arg11 = (size_t *)SWIG_MustGetPtr(argv[10], SWIGTYPE_p_size_t, 11, 0);
  }
  {
    arg12 = (int *)SWIG_MustGetPtr(argv[11], SWIGTYPE_p_int, 12, 0);
  }
  {
    arg13 = (size_t *)SWIG_MustGetPtr(argv[12], SWIGTYPE_p_size_t, 13, 0);
  }
  {
    arg14 = (meep::direction *)SWIG_MustGetPtr(argv[13], SWIGTYPE_p_meep__direction, 14, 0);
  }
  (arg1)->get_dft_component_dims(arg2,arg3,arg4,*arg5,*arg6,*arg7,*arg8,*arg9,arg10,arg11,arg12,arg13,arg14);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_dft_component_dims__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-dft-component-dims"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  meep::component arg4 ;
  meep::ivec *arg5 = 0 ;
  meep::ivec *arg6 = 0 ;
  size_t *arg7 = 0 ;
  size_t *arg8 = 0 ;
  int *arg9 = 0 ;
  meep::direction *arg10 = (meep::direction *) 0 ;
  size_t *arg11 = (size_t *) 0 ;
  int *arg12 = (int *) 0 ;
  size_t *arg13 = (size_t *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (meep::component) scm_to_int(argv[3]); 
  }
  {
    arg5 = (meep::ivec *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__ivec, 5, 0);
  }
  {
    arg6 = (meep::ivec *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__ivec, 6, 0);
  }
  {
    arg7 = (size_t *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_size_t, 7, 0);
  }
  {
    arg8 = (size_t *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_size_t, 8, 0);
  }
  {
    arg9 = (int *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_int, 9, 0);
  }
  {
    arg10 = (meep::direction *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_meep__direction, 10, 0);
  }
  {
    arg11 = (size_t *)SWIG_MustGetPtr(argv[10], SWIGTYPE_p_size_t, 11, 0);
  }
  {
    arg12 = (int *)SWIG_MustGetPtr(argv[11], SWIGTYPE_p_int, 12, 0);
  }
  {
    arg13 = (size_t *)SWIG_MustGetPtr(argv[12], SWIGTYPE_p_size_t, 13, 0);
  }
  (arg1)->get_dft_component_dims(arg2,arg3,arg4,*arg5,*arg6,*arg7,*arg8,*arg9,arg10,arg11,arg12,arg13);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_dft_component_dims__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-dft-component-dims"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  meep::component arg4 ;
  meep::ivec *arg5 = 0 ;
  meep::ivec *arg6 = 0 ;
  size_t *arg7 = 0 ;
  size_t *arg8 = 0 ;
  int *arg9 = 0 ;
  meep::direction *arg10 = (meep::direction *) 0 ;
  size_t *arg11 = (size_t *) 0 ;
  int *arg12 = (int *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (meep::component) scm_to_int(argv[3]); 
  }
  {
    arg5 = (meep::ivec *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__ivec, 5, 0);
  }
  {
    arg6 = (meep::ivec *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__ivec, 6, 0);
  }
  {
    arg7 = (size_t *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_size_t, 7, 0);
  }
  {
    arg8 = (size_t *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_size_t, 8, 0);
  }
  {
    arg9 = (int *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_int, 9, 0);
  }
  {
    arg10 = (meep::direction *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_meep__direction, 10, 0);
  }
  {
    arg11 = (size_t *)SWIG_MustGetPtr(argv[10], SWIGTYPE_p_size_t, 11, 0);
  }
  {
    arg12 = (int *)SWIG_MustGetPtr(argv[11], SWIGTYPE_p_int, 12, 0);
  }
  (arg1)->get_dft_component_dims(arg2,arg3,arg4,*arg5,*arg6,*arg7,*arg8,*arg9,arg10,arg11,arg12);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_dft_component_dims__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-dft-component-dims"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::dft_chunk **arg2 = (meep::dft_chunk **) 0 ;
  int arg3 ;
  meep::component arg4 ;
  meep::ivec *arg5 = 0 ;
  meep::ivec *arg6 = 0 ;
  size_t *arg7 = 0 ;
  size_t *arg8 = 0 ;
  int *arg9 = 0 ;
  meep::direction *arg10 = (meep::direction *) 0 ;
  size_t *arg11 = (size_t *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::dft_chunk **)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_p_meep__dft_chunk, 2, 0);
  }
  {
    arg3 = (int) scm_to_int(argv[2]);
  }
  {
    arg4 = (meep::component) scm_to_int(argv[3]); 
  }
  {
    arg5 = (meep::ivec *)SWIG_MustGetPtr(argv[4], SWIGTYPE_p_meep__ivec, 5, 0);
  }
  {
    arg6 = (meep::ivec *)SWIG_MustGetPtr(argv[5], SWIGTYPE_p_meep__ivec, 6, 0);
  }
  {
    arg7 = (size_t *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_size_t, 7, 0);
  }
  {
    arg8 = (size_t *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_size_t, 8, 0);
  }
  {
    arg9 = (int *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_int, 9, 0);
  }
  {
    arg10 = (meep::direction *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_meep__direction, 10, 0);
  }
  {
    arg11 = (size_t *)SWIG_MustGetPtr(argv[10], SWIGTYPE_p_size_t, 11, 0);
  }
  (arg1)->get_dft_component_dims(arg2,arg3,arg4,*arg5,*arg6,*arg7,*arg8,*arg9,arg10,arg11);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_dft_component_dims(SCM rest)
{
#define FUNC_NAME "meep-fields-get-dft-component-dims"
  SCM argv[14];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 14, "meep-fields-get-dft-component-dims");
  if (argc == 11) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_size_t, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_size_t, SWIG_POINTER_NO_NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_meep__direction, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, SWIGTYPE_p_size_t, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_meep_fields_get_dft_component_dims__SWIG_3(argc,argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_size_t, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_size_t, SWIG_POINTER_NO_NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_meep__direction, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, SWIGTYPE_p_size_t, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_meep_fields_get_dft_component_dims__SWIG_2(argc,argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_size_t, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_size_t, SWIG_POINTER_NO_NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_meep__direction, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, SWIGTYPE_p_size_t, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              void *ptr;
                              int res = SWIG_ConvertPtr(argv[12], &ptr, SWIGTYPE_p_size_t, 0);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_meep_fields_get_dft_component_dims__SWIG_1(argc,argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_p_meep__dft_chunk, 0);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              void *ptr;
              int res = SWIG_ConvertPtr(argv[4], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                void *ptr;
                int res = SWIG_ConvertPtr(argv[5], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_size_t, SWIG_POINTER_NO_NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_size_t, SWIG_POINTER_NO_NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_meep__direction, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          void *ptr;
                          int res = SWIG_ConvertPtr(argv[10], &ptr, SWIGTYPE_p_size_t, 0);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            void *ptr;
                            int res = SWIG_ConvertPtr(argv[11], &ptr, SWIGTYPE_p_int, 0);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              void *ptr;
                              int res = SWIG_ConvertPtr(argv[12], &ptr, SWIGTYPE_p_size_t, 0);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                void *ptr;
                                int res = SWIG_ConvertPtr(argv[13], &ptr, SWIGTYPE_p_meep__direction, 0);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_meep_fields_get_dft_component_dims__SWIG_0(argc,argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-get-dft-component-dims", "No matching method for generic function `meep_fields_get_dft_component_dims'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_synchronize_magnetic_fields (SCM s_0)
{
#define FUNC_NAME "meep-fields-synchronize-magnetic-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->synchronize_magnetic_fields();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_restore_magnetic_fields (SCM s_0)
{
#define FUNC_NAME "meep-fields-restore-magnetic-fields"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->restore_magnetic_fields();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_energy_in_box (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-energy-in-box"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  result = (double)(arg1)->energy_in_box((meep::volume const &)*arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_electric_energy_in_box (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-electric-energy-in-box"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  result = (double)(arg1)->electric_energy_in_box((meep::volume const &)*arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_magnetic_energy_in_box (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-magnetic-energy-in-box"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  result = (double)(arg1)->magnetic_energy_in_box((meep::volume const &)*arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_thermo_energy_in_box (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-thermo-energy-in-box"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  result = (double)(arg1)->thermo_energy_in_box((meep::volume const &)*arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_total_energy (SCM s_0)
{
#define FUNC_NAME "meep-fields-total-energy"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double)(arg1)->total_energy();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_field_energy_in_box__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-field-energy-in-box"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  result = (double)(arg1)->field_energy_in_box((meep::volume const &)*arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_field_energy_in_box__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-field-energy-in-box"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__volume, 3, 0);
  }
  result = (double)(arg1)->field_energy_in_box(arg2,(meep::volume const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_field_energy_in_box(SCM rest)
{
#define FUNC_NAME "meep-fields-field-energy-in-box"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-fields-field-energy-in-box");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_fields_field_energy_in_box__SWIG_0(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_field_energy_in_box__SWIG_1(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-field-energy-in-box", "No matching method for generic function `meep_fields_field_energy_in_box'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_field_energy (SCM s_0)
{
#define FUNC_NAME "meep-fields-field-energy"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double)(arg1)->field_energy();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_flux_in_box_wrongH (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-fields-flux-in-box-wrongH"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__volume, 3, 0);
  }
  result = (double)(arg1)->flux_in_box_wrongH(arg2,(meep::volume const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_flux_in_box (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-fields-flux-in-box"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__volume, 3, 0);
  }
  result = (double)(arg1)->flux_in_box(arg2,(meep::volume const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_flux_vol (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-fields-add-flux-vol"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::flux_vol *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__volume, 3, 0);
  }
  result = (meep::flux_vol *)(arg1)->add_flux_vol(arg2,(meep::volume const &)*arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__flux_vol, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_flux_plane__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-flux-plane"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::flux_vol *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_meep__volume, 2, 0);
  }
  result = (meep::flux_vol *)(arg1)->add_flux_plane((meep::volume const &)*arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__flux_vol, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_flux_plane__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-add-flux-plane"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::vec *arg2 = 0 ;
  meep::vec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::flux_vol *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(argv[1]));
  arg2 = &vec__arg2;
  
  
  meep::vec vec__arg3 = vector3_to_vec(ctl_convert_vector3_to_c(argv[2]));
  arg3 = &vec__arg3;
  
  result = (meep::flux_vol *)(arg1)->add_flux_plane((meep::vec const &)*arg2,(meep::vec const &)*arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__flux_vol, 0);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_add_flux_plane(SCM rest)
{
#define FUNC_NAME "meep-fields-add-flux-plane"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "meep-fields-add-flux-plane");
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_meep_fields_add_flux_plane__SWIG_0(argc,argv);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SwigVector3_Check(argv[1]);
      }
      if (_v) {
        {
          _v = SwigVector3_Check(argv[2]);
        }
        if (_v) {
          return _wrap_meep_fields_add_flux_plane__SWIG_1(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-add-flux-plane", "No matching method for generic function `meep_fields_add_flux_plane'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_electric_energy_max_in_box (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-electric-energy-max-in-box"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  result = (double)(arg1)->electric_energy_max_in_box((meep::volume const &)*arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_modal_volume_in_box (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-modal-volume-in-box"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  result = (double)(arg1)->modal_volume_in_box((meep::volume const &)*arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_electric_sqr_weighted_integral (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-fields-electric-sqr-weighted-integral"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  meep::volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(s_1, SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__volume, 3, 0);
  }
  result = (double)(arg1)->electric_sqr_weighted_integral(arg2,(meep::volume const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_electric_energy_weighted_integral (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-fields-electric-energy-weighted-integral"
  meep::fields *arg1 = (meep::fields *) 0 ;
  double (*arg2)(meep::vec const &) = (double (*)(meep::vec const &)) 0 ;
  meep::volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (double (*)(meep::vec const &))SWIG_MustGetPtr(s_1, SWIGTYPE_p_f_r_q_const__meep__vec__double, 2, 0);
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__volume, 3, 0);
  }
  result = (double)(arg1)->electric_energy_weighted_integral(arg2,(meep::volume const &)*arg3);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_set_output_directory (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-set-output-directory"
  meep::fields *arg1 = (meep::fields *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  (arg1)->set_output_directory((char const *)arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_count_volume (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-count-volume"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = (double)(arg1)->count_volume(arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_have_component (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-have-component"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(s_1); 
  }
  result = (bool)(arg1)->have_component(arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_max_eps (SCM s_0)
{
#define FUNC_NAME "meep-fields-max-eps"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = (double)((meep::fields const *)arg1)->max_eps();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_step_boundaries (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-step-boundaries"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::field_type arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::field_type) scm_to_int(s_1); 
  }
  (arg1)->step_boundaries(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_process_incoming_chunk_data (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-fields-process-incoming-chunk-data"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::field_type arg2 ;
  meep::chunk_pair *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::field_type) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::chunk_pair *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_std__pairT_int_int_t, 3, 0);
  }
  (arg1)->process_incoming_chunk_data(arg2,(meep::chunk_pair const &)*arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_nosize_direction (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-nosize-direction"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  result = (bool)((meep::fields const *)arg1)->nosize_direction(arg2);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_normal_direction (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-normal-direction"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::volume *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::direction result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::volume *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__volume, 2, 0);
  }
  result = (meep::direction)((meep::fields const *)arg1)->normal_direction((meep::volume const &)*arg2);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_casimir_stress_dct_integral__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-casimir-stress-dct-integral"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::direction arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  meep::field_type arg7 ;
  SwigValueWrapper< meep::volume > arg8 ;
  bool arg9 ;
  meep::volume *argp8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (meep::field_type) scm_to_int(argv[6]); 
  }
  {
    argp8 = (meep::volume *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__volume, 8, 0);
    arg8 = *argp8;
  }
  {
    arg9 = (bool) scm_is_true(argv[8]);
  }
  result = (arg1)->casimir_stress_dct_integral(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_casimir_stress_dct_integral__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-casimir-stress-dct-integral"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::direction arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  meep::field_type arg7 ;
  SwigValueWrapper< meep::volume > arg8 ;
  meep::volume *argp8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  {
    arg7 = (meep::field_type) scm_to_int(argv[6]); 
  }
  {
    argp8 = (meep::volume *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_meep__volume, 8, 0);
    arg8 = *argp8;
  }
  result = (arg1)->casimir_stress_dct_integral(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_casimir_stress_dct_integral(SCM rest)
{
#define FUNC_NAME "meep-fields-casimir-stress-dct-integral"
  SCM argv[9];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 9, "meep-fields-casimir-stress-dct-integral");
  if (argc == 8) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_meep_fields_casimir_stress_dct_integral__SWIG_1(argc,argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                {
                  _v = scm_is_true(scm_integer_p(argv[6])) && scm_is_true(scm_exact_p(argv[6]))? 1 : 0;
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_meep__volume, SWIG_POINTER_NO_NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      _v = SCM_BOOLP(argv[8]) ? 1 : 0;
                    }
                    if (_v) {
                      return _wrap_meep_fields_casimir_stress_dct_integral__SWIG_0(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-casimir-stress-dct-integral", "No matching method for generic function `meep_fields_casimir_stress_dct_integral'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_set_solve_cw_omega (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-set-solve-cw-omega"
  meep::fields *arg1 = (meep::fields *) 0 ;
  std::complex< double > arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_1);
    arg2 = std::complex<double>(cnum.re, cnum.im);
  }
  (arg1)->set_solve_cw_omega(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_unset_solve_cw_omega (SCM s_0)
{
#define FUNC_NAME "meep-fields-unset-solve-cw-omega"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->unset_solve_cw_omega();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_field__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-field"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::ivec *arg3 = 0 ;
  bool arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::ivec *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__ivec, 3, 0);
  }
  {
    arg4 = (bool) scm_is_true(argv[3]);
  }
  result = ((meep::fields const *)arg1)->get_field(arg2,(meep::ivec const &)*arg3,arg4);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_field__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-field"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::ivec *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::ivec *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_meep__ivec, 3, 0);
  }
  result = ((meep::fields const *)arg1)->get_field(arg2,(meep::ivec const &)*arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_field(SCM rest)
{
#define FUNC_NAME "meep-fields-get-field"
  SCM argv[4];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 4, "meep-fields-get-field");
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_meep_fields_get_field__SWIG_7(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SwigVector3_Check(argv[2]);
        }
        if (_v) {
          return _wrap_meep_fields_get_field__SWIG_3(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SwigVector3_Check(argv[2]);
        }
        if (_v) {
          return _wrap_meep_fields_get_field__SWIG_5(argc,argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SwigVector3_Check(argv[2]);
        }
        if (_v) {
          return _wrap_meep_fields_get_field__SWIG_1(argc,argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_get_field__SWIG_6(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SwigVector3_Check(argv[2]);
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_get_field__SWIG_2(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SwigVector3_Check(argv[2]);
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_get_field__SWIG_4(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = SwigVector3_Check(argv[2]);
        }
        if (_v) {
          {
            _v = SCM_BOOLP(argv[3]) ? 1 : 0;
          }
          if (_v) {
            return _wrap_meep_fields_get_field__SWIG_0(argc,argv);
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-get-field", "No matching method for generic function `meep_fields_get_field'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_chi1inv__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-chi1inv"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::ivec *arg4 = 0 ;
  double arg5 ;
  bool arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::ivec *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__ivec, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (bool) scm_is_true(argv[5]);
  }
  result = ((meep::fields const *)arg1)->get_chi1inv(arg2,arg3,(meep::ivec const &)*arg4,arg5,arg6);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_chi1inv__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-chi1inv"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::ivec *arg4 = 0 ;
  double arg5 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::ivec *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__ivec, 4, 0);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  result = ((meep::fields const *)arg1)->get_chi1inv(arg2,arg3,(meep::ivec const &)*arg4,arg5);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_chi1inv__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-fields-get-chi1inv"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component arg2 ;
  meep::direction arg3 ;
  meep::ivec *arg4 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component) scm_to_int(argv[1]); 
  }
  {
    arg3 = (meep::direction) scm_to_int(argv[2]); 
  }
  {
    arg4 = (meep::ivec *)SWIG_MustGetPtr(argv[3], SWIGTYPE_p_meep__ivec, 4, 0);
  }
  result = ((meep::fields const *)arg1)->get_chi1inv(arg2,arg3,(meep::ivec const &)*arg4);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_chi1inv(SCM rest)
{
#define FUNC_NAME "meep-fields-get-chi1inv"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "meep-fields-get-chi1inv");
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_meep_fields_get_chi1inv__SWIG_5(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigVector3_Check(argv[3]);
          }
          if (_v) {
            return _wrap_meep_fields_get_chi1inv__SWIG_2(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_get_chi1inv__SWIG_4(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigVector3_Check(argv[3]);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              return _wrap_meep_fields_get_chi1inv__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            void *ptr;
            int res = SWIG_ConvertPtr(argv[3], &ptr, SWIGTYPE_p_meep__ivec, SWIG_POINTER_NO_NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_get_chi1inv__SWIG_3(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__fields, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_integer_p(argv[2])) && scm_is_true(scm_exact_p(argv[2]))? 1 : 0;
        }
        if (_v) {
          {
            _v = SwigVector3_Check(argv[3]);
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = SCM_BOOLP(argv[5]) ? 1 : 0;
              }
              if (_v) {
                return _wrap_meep_fields_get_chi1inv__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-fields-get-chi1inv", "No matching method for generic function `meep_fields_get_chi1inv'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_locate_component_point (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-fields-locate-component-point"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::component *arg2 = (meep::component *) 0 ;
  meep::ivec *arg3 = (meep::ivec *) 0 ;
  std::complex< double > *arg4 = (std::complex< double > *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::component *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__component, 2, 0);
  }
  {
    arg3 = (meep::ivec *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__ivec, 3, 0);
  }
  {
    arg4 = (std::complex< double > *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_std__complexT_double_t, 4, 0);
  }
  result = (bool)((meep::fields const *)arg1)->locate_component_point(arg2,arg3,arg4);
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_am_now_working_on (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-am-now-working-on"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::time_sink arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::time_sink) scm_to_int(s_1); 
  }
  (arg1)->am_now_working_on(arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_finished_working (SCM s_0)
{
#define FUNC_NAME "meep-fields-finished-working"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->finished_working();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_time_spent_on (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-fields-get-time-spent-on"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::time_sink arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::time_sink) scm_to_int(s_1); 
  }
  result = (double)((meep::fields const *)arg1)->get_time_spent_on(arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_get_timing_data (SCM s_0)
{
#define FUNC_NAME "meep-fields-get-timing-data"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::unordered_map< meep::time_sink,std::vector< double >,std::hash< int > > result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  result = ((meep::fields const *)arg1)->get_timing_data();
  {
    std::unordered_map< meep::time_sink,std::vector< double >,std::hash< int > > * resultptr;
    resultptr = new std::unordered_map< meep::time_sink,std::vector< double >,std::hash< int > >((const std::unordered_map< meep::time_sink,std::vector< double >,std::hash< int > > &) result);
    gswig_result =  SWIG_NewPointerObj (resultptr, SWIGTYPE_p_std__unordered_mapT_meep__time_sink_std__vectorT_double_t_std__hashT_int_t_t, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_fields_reset_timers (SCM s_0)
{
#define FUNC_NAME "meep-fields-reset-timers"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  (arg1)->reset_timers();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_flux_vol (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "new-meep-flux-vol"
  meep::fields *arg1 = (meep::fields *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::flux_vol *result = 0 ;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__volume, 3, 0);
  }
  result = (meep::flux_vol *)new meep::flux_vol(arg1,arg2,(meep::volume const &)*arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__flux_vol, 1);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_flux_vol (SCM s_0)
{
#define FUNC_NAME "delete-meep-flux-vol"
  meep::flux_vol *arg1 = (meep::flux_vol *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::flux_vol *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__flux_vol, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_flux_vol_update_half (SCM s_0)
{
#define FUNC_NAME "meep-flux-vol-update-half"
  meep::flux_vol *arg1 = (meep::flux_vol *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::flux_vol *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__flux_vol, 1, 0);
  }
  (arg1)->update_half();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_flux_vol_update (SCM s_0)
{
#define FUNC_NAME "meep-flux-vol-update"
  meep::flux_vol *arg1 = (meep::flux_vol *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::flux_vol *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__flux_vol, 1, 0);
  }
  (arg1)->update();
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_flux_vol_flux (SCM s_0)
{
#define FUNC_NAME "meep-flux-vol-flux"
  meep::flux_vol *arg1 = (meep::flux_vol *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::flux_vol *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__flux_vol, 1, 0);
  }
  result = (double)(arg1)->flux();
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_flux_vol_next_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-flux-vol-next-set"
  meep::flux_vol *arg1 = (meep::flux_vol *) 0 ;
  meep::flux_vol *arg2 = (meep::flux_vol *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::flux_vol *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__flux_vol, 1, 0);
  }
  {
    arg2 = (meep::flux_vol *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__flux_vol, 2, 0);
  }
  if (arg1) (arg1)->next = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_flux_vol_next_get (SCM s_0)
{
#define FUNC_NAME "meep-flux-vol-next-get"
  meep::flux_vol *arg1 = (meep::flux_vol *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::flux_vol *result = 0 ;
  
  {
    arg1 = (meep::flux_vol *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__flux_vol, 1, 0);
  }
  result = (meep::flux_vol *) ((arg1)->next);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__flux_vol, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_make_output_directory__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-make-output-directory"
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free1 = 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (char *)SWIG_scm2str(argv[0]);
    must_free1 = 1;
  }
  {
    arg2 = (char *)SWIG_scm2str(argv[1]);
    must_free2 = 1;
  }
  result = (char *)meep::make_output_directory((char const *)arg1,(char const *)arg2);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  if (must_free1 && arg1) SWIG_free(arg1);
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_make_output_directory__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-make-output-directory"
  char *arg1 = (char *) 0 ;
  int must_free1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  {
    arg1 = (char *)SWIG_scm2str(argv[0]);
    must_free1 = 1;
  }
  result = (char *)meep::make_output_directory((char const *)arg1);
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  if (must_free1 && arg1) SWIG_free(arg1);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_make_output_directory__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-make-output-directory"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  char *result = 0 ;
  
  result = (char *)meep::make_output_directory();
  {
    gswig_result = SWIG_str02scm((const char *)result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_make_output_directory(SCM rest)
{
#define FUNC_NAME "meep-make-output-directory"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-make-output-directory");
  if (argc == 0) {
    return _wrap_meep_make_output_directory__SWIG_2(argc,argv);
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_string(argv[0]) ? 1 : 0;
    }
    if (_v) {
      return _wrap_meep_make_output_directory__SWIG_1(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      _v = scm_is_string(argv[0]) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_string(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_make_output_directory__SWIG_0(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-make-output-directory", "No matching method for generic function `meep_make_output_directory'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_trash_output_directory (SCM s_0)
{
#define FUNC_NAME "meep-trash-output-directory"
  char *arg1 = (char *) 0 ;
  int must_free1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (char *)SWIG_scm2str(s_0);
    must_free1 = 1;
  }
  meep::trash_output_directory((char const *)arg1);
  gswig_result = SCM_UNSPECIFIED;
  if (must_free1 && arg1) SWIG_free(arg1);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_delete_directory (SCM s_0)
{
#define FUNC_NAME "meep-delete-directory"
  char *arg1 = (char *) 0 ;
  int must_free1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (char *)SWIG_scm2str(s_0);
    must_free1 = 1;
  }
  meep::delete_directory((char const *)arg1);
  gswig_result = SCM_UNSPECIFIED;
  if (must_free1 && arg1) SWIG_free(arg1);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_create_output_file (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-create-output-file"
  char *arg1 = (char *) 0 ;
  char *arg2 = (char *) 0 ;
  int must_free1 = 0 ;
  int must_free2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  FILE *result = 0 ;
  
  {
    arg1 = (char *)SWIG_scm2str(s_0);
    must_free1 = 1;
  }
  {
    arg2 = (char *)SWIG_scm2str(s_1);
    must_free2 = 1;
  }
  result = (FILE *)meep::create_output_file((char const *)arg1,(char const *)arg2);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_FILE, 0);
  }
  if (must_free1 && arg1) SWIG_free(arg1);
  if (must_free2 && arg2) SWIG_free(arg2);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_do_harminv__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-do-harminv"
  std::complex< double > *arg1 = (std::complex< double > *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  std::complex< double > *arg7 = (std::complex< double > *) 0 ;
  double *arg8 = (double *) 0 ;
  double *arg9 = (double *) 0 ;
  double *arg10 = (double *) 0 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  double arg16 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (std::complex< double > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_double_t, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (std::complex< double > *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (double *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_double, 8, 0);
  }
  {
    arg9 = (double *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_double, 9, 0);
  }
  {
    arg10 = (double *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_double, 10, 0);
  }
  {
    arg11 = (double) scm_to_double(argv[10]);
  }
  {
    arg12 = (double) scm_to_double(argv[11]);
  }
  {
    arg13 = (double) scm_to_double(argv[12]);
  }
  {
    arg14 = (double) scm_to_double(argv[13]);
  }
  {
    arg15 = (double) scm_to_double(argv[14]);
  }
  {
    arg16 = (double) scm_to_double(argv[15]);
  }
  result = (int)meep::do_harminv(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_do_harminv__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-do-harminv"
  std::complex< double > *arg1 = (std::complex< double > *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  std::complex< double > *arg7 = (std::complex< double > *) 0 ;
  double *arg8 = (double *) 0 ;
  double *arg9 = (double *) 0 ;
  double *arg10 = (double *) 0 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  double arg15 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (std::complex< double > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_double_t, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (std::complex< double > *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (double *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_double, 8, 0);
  }
  {
    arg9 = (double *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_double, 9, 0);
  }
  {
    arg10 = (double *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_double, 10, 0);
  }
  {
    arg11 = (double) scm_to_double(argv[10]);
  }
  {
    arg12 = (double) scm_to_double(argv[11]);
  }
  {
    arg13 = (double) scm_to_double(argv[12]);
  }
  {
    arg14 = (double) scm_to_double(argv[13]);
  }
  {
    arg15 = (double) scm_to_double(argv[14]);
  }
  result = (int)meep::do_harminv(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_do_harminv__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-do-harminv"
  std::complex< double > *arg1 = (std::complex< double > *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  std::complex< double > *arg7 = (std::complex< double > *) 0 ;
  double *arg8 = (double *) 0 ;
  double *arg9 = (double *) 0 ;
  double *arg10 = (double *) 0 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  double arg14 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (std::complex< double > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_double_t, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (std::complex< double > *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (double *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_double, 8, 0);
  }
  {
    arg9 = (double *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_double, 9, 0);
  }
  {
    arg10 = (double *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_double, 10, 0);
  }
  {
    arg11 = (double) scm_to_double(argv[10]);
  }
  {
    arg12 = (double) scm_to_double(argv[11]);
  }
  {
    arg13 = (double) scm_to_double(argv[12]);
  }
  {
    arg14 = (double) scm_to_double(argv[13]);
  }
  result = (int)meep::do_harminv(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_do_harminv__SWIG_3 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-do-harminv"
  std::complex< double > *arg1 = (std::complex< double > *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  std::complex< double > *arg7 = (std::complex< double > *) 0 ;
  double *arg8 = (double *) 0 ;
  double *arg9 = (double *) 0 ;
  double *arg10 = (double *) 0 ;
  double arg11 ;
  double arg12 ;
  double arg13 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (std::complex< double > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_double_t, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (std::complex< double > *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (double *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_double, 8, 0);
  }
  {
    arg9 = (double *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_double, 9, 0);
  }
  {
    arg10 = (double *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_double, 10, 0);
  }
  {
    arg11 = (double) scm_to_double(argv[10]);
  }
  {
    arg12 = (double) scm_to_double(argv[11]);
  }
  {
    arg13 = (double) scm_to_double(argv[12]);
  }
  result = (int)meep::do_harminv(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_do_harminv__SWIG_4 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-do-harminv"
  std::complex< double > *arg1 = (std::complex< double > *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  std::complex< double > *arg7 = (std::complex< double > *) 0 ;
  double *arg8 = (double *) 0 ;
  double *arg9 = (double *) 0 ;
  double *arg10 = (double *) 0 ;
  double arg11 ;
  double arg12 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (std::complex< double > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_double_t, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (std::complex< double > *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (double *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_double, 8, 0);
  }
  {
    arg9 = (double *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_double, 9, 0);
  }
  {
    arg10 = (double *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_double, 10, 0);
  }
  {
    arg11 = (double) scm_to_double(argv[10]);
  }
  {
    arg12 = (double) scm_to_double(argv[11]);
  }
  result = (int)meep::do_harminv(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_do_harminv__SWIG_5 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-do-harminv"
  std::complex< double > *arg1 = (std::complex< double > *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  std::complex< double > *arg7 = (std::complex< double > *) 0 ;
  double *arg8 = (double *) 0 ;
  double *arg9 = (double *) 0 ;
  double *arg10 = (double *) 0 ;
  double arg11 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (std::complex< double > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_double_t, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (std::complex< double > *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (double *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_double, 8, 0);
  }
  {
    arg9 = (double *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_double, 9, 0);
  }
  {
    arg10 = (double *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_double, 10, 0);
  }
  {
    arg11 = (double) scm_to_double(argv[10]);
  }
  result = (int)meep::do_harminv(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_do_harminv__SWIG_6 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-do-harminv"
  std::complex< double > *arg1 = (std::complex< double > *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  std::complex< double > *arg7 = (std::complex< double > *) 0 ;
  double *arg8 = (double *) 0 ;
  double *arg9 = (double *) 0 ;
  double *arg10 = (double *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (std::complex< double > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_double_t, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (std::complex< double > *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (double *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_double, 8, 0);
  }
  {
    arg9 = (double *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_double, 9, 0);
  }
  {
    arg10 = (double *)SWIG_MustGetPtr(argv[9], SWIGTYPE_p_double, 10, 0);
  }
  result = (int)meep::do_harminv(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_do_harminv__SWIG_7 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-do-harminv"
  std::complex< double > *arg1 = (std::complex< double > *) 0 ;
  int arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  int arg6 ;
  std::complex< double > *arg7 = (std::complex< double > *) 0 ;
  double *arg8 = (double *) 0 ;
  double *arg9 = (double *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (std::complex< double > *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_std__complexT_double_t, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (double) scm_to_double(argv[3]);
  }
  {
    arg5 = (double) scm_to_double(argv[4]);
  }
  {
    arg6 = (int) scm_to_int(argv[5]);
  }
  {
    arg7 = (std::complex< double > *)SWIG_MustGetPtr(argv[6], SWIGTYPE_p_std__complexT_double_t, 7, 0);
  }
  {
    arg8 = (double *)SWIG_MustGetPtr(argv[7], SWIGTYPE_p_double, 8, 0);
  }
  {
    arg9 = (double *)SWIG_MustGetPtr(argv[8], SWIGTYPE_p_double, 9, 0);
  }
  result = (int)meep::do_harminv(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    gswig_result = scm_from_long(result);
  }
  
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_do_harminv(SCM rest)
{
#define FUNC_NAME "meep-do-harminv"
  SCM argv[16];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 16, "meep-do-harminv");
  if (argc == 9) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_meep_do_harminv__SWIG_7(argc,argv);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_meep_do_harminv__SWIG_6(argc,argv);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_real_p(argv[10])) ? 1 : 0;
                        }
                        if (_v) {
                          return _wrap_meep_do_harminv__SWIG_5(argc,argv);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_real_p(argv[10])) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            _v = scm_is_true(scm_real_p(argv[11])) ? 1 : 0;
                          }
                          if (_v) {
                            return _wrap_meep_do_harminv__SWIG_4(argc,argv);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_real_p(argv[10])) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            _v = scm_is_true(scm_real_p(argv[11])) ? 1 : 0;
                          }
                          if (_v) {
                            {
                              _v = scm_is_true(scm_real_p(argv[12])) ? 1 : 0;
                            }
                            if (_v) {
                              return _wrap_meep_do_harminv__SWIG_3(argc,argv);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_real_p(argv[10])) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            _v = scm_is_true(scm_real_p(argv[11])) ? 1 : 0;
                          }
                          if (_v) {
                            {
                              _v = scm_is_true(scm_real_p(argv[12])) ? 1 : 0;
                            }
                            if (_v) {
                              {
                                _v = scm_is_true(scm_real_p(argv[13])) ? 1 : 0;
                              }
                              if (_v) {
                                return _wrap_meep_do_harminv__SWIG_2(argc,argv);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_real_p(argv[10])) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            _v = scm_is_true(scm_real_p(argv[11])) ? 1 : 0;
                          }
                          if (_v) {
                            {
                              _v = scm_is_true(scm_real_p(argv[12])) ? 1 : 0;
                            }
                            if (_v) {
                              {
                                _v = scm_is_true(scm_real_p(argv[13])) ? 1 : 0;
                              }
                              if (_v) {
                                {
                                  _v = scm_is_true(scm_real_p(argv[14])) ? 1 : 0;
                                }
                                if (_v) {
                                  return _wrap_meep_do_harminv__SWIG_1(argc,argv);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = scm_is_true(scm_integer_p(argv[1])) && scm_is_true(scm_exact_p(argv[1]))? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_real_p(argv[3])) ? 1 : 0;
          }
          if (_v) {
            {
              _v = scm_is_true(scm_real_p(argv[4])) ? 1 : 0;
            }
            if (_v) {
              {
                _v = scm_is_true(scm_integer_p(argv[5])) && scm_is_true(scm_exact_p(argv[5]))? 1 : 0;
              }
              if (_v) {
                {
                  void *ptr;
                  int res = SWIG_ConvertPtr(argv[6], &ptr, SWIGTYPE_p_std__complexT_double_t, 0);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    void *ptr;
                    int res = SWIG_ConvertPtr(argv[7], &ptr, SWIGTYPE_p_double, 0);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      void *ptr;
                      int res = SWIG_ConvertPtr(argv[8], &ptr, SWIGTYPE_p_double, 0);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        void *ptr;
                        int res = SWIG_ConvertPtr(argv[9], &ptr, SWIGTYPE_p_double, 0);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          _v = scm_is_true(scm_real_p(argv[10])) ? 1 : 0;
                        }
                        if (_v) {
                          {
                            _v = scm_is_true(scm_real_p(argv[11])) ? 1 : 0;
                          }
                          if (_v) {
                            {
                              _v = scm_is_true(scm_real_p(argv[12])) ? 1 : 0;
                            }
                            if (_v) {
                              {
                                _v = scm_is_true(scm_real_p(argv[13])) ? 1 : 0;
                              }
                              if (_v) {
                                {
                                  _v = scm_is_true(scm_real_p(argv[14])) ? 1 : 0;
                                }
                                if (_v) {
                                  {
                                    _v = scm_is_true(scm_real_p(argv[15])) ? 1 : 0;
                                  }
                                  if (_v) {
                                    return _wrap_meep_do_harminv__SWIG_0(argc,argv);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("meep-do-harminv", "No matching method for generic function `meep_do_harminv'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_make_casimir_gfunc__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "make-casimir-gfunc"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  meep::field_type arg4 ;
  std::complex< double > (*arg5)(std::complex< double >) = (std::complex< double > (*)(std::complex< double >)) 0 ;
  double arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > *result = 0 ;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (meep::field_type) scm_to_int(argv[3]); 
  }
  {
    my_complex_func3_scm = argv[4];
    arg5 = my_complex_func3;
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  result = (std::complex< double > *)meep::make_casimir_gfunc(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_make_casimir_gfunc__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "make-casimir-gfunc"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  meep::field_type arg4 ;
  std::complex< double > (*arg5)(std::complex< double >) = (std::complex< double > (*)(std::complex< double >)) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > *result = 0 ;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (meep::field_type) scm_to_int(argv[3]); 
  }
  {
    my_complex_func3_scm = argv[4];
    arg5 = my_complex_func3;
  }
  result = (std::complex< double > *)meep::make_casimir_gfunc(arg1,arg2,arg3,arg4,arg5);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_make_casimir_gfunc__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "make-casimir-gfunc"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  meep::field_type arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > *result = 0 ;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (meep::field_type) scm_to_int(argv[3]); 
  }
  result = (std::complex< double > *)meep::make_casimir_gfunc(arg1,arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_make_casimir_gfunc(SCM rest)
{
#define FUNC_NAME "make-casimir-gfunc"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "make-casimir-gfunc");
  if (argc == 4) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            return _wrap_make_casimir_gfunc__SWIG_2(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_NFALSEP(scm_procedure_p(argv[4]));
            }
            if (_v) {
              return _wrap_make_casimir_gfunc__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_NFALSEP(scm_procedure_p(argv[4]));
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                return _wrap_make_casimir_gfunc__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("make-casimir-gfunc", "No matching method for generic function `make_casimir_gfunc'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_make_casimir_gfunc_kz (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "meep-make-casimir-gfunc-kz"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  meep::field_type arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > *result = 0 ;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  {
    arg4 = (meep::field_type) scm_to_int(s_3); 
  }
  result = (std::complex< double > *)meep::make_casimir_gfunc_kz(arg1,arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_std__complexT_double_t, 0);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_set_random_seed (SCM s_0)
{
#define FUNC_NAME "meep-set-random-seed"
  unsigned long arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (unsigned long) scm_to_ulong(s_0);
  }
  meep::set_random_seed(arg1);
  gswig_result = SCM_UNSPECIFIED;
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_restore_random_seed ()
{
#define FUNC_NAME "meep-restore-random-seed"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  meep::restore_random_seed();
  gswig_result = SCM_UNSPECIFIED;
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_uniform_random (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-uniform-random"
  double arg1 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  result = (double)meep::uniform_random(arg1,arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_gaussian_random (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-gaussian-random"
  double arg1 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  result = (double)meep::gaussian_random(arg1,arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_random_int (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-random-int"
  int arg1 ;
  int arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (int) scm_to_int(s_0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  result = (int)meep::random_int(arg1,arg2);
  {
    gswig_result = scm_from_long(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_BesselJ (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-BesselJ"
  int arg1 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (int) scm_to_int(s_0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  result = (double)meep::BesselJ(arg1,arg2);
  {
    gswig_result = scm_from_double(result);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_green2d (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5, SCM s_6, SCM s_7)
{
#define FUNC_NAME "meep-green2d"
  std::complex< double > *arg1 = (std::complex< double > *) 0 ;
  meep::vec *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  meep::vec *arg6 = 0 ;
  meep::component arg7 ;
  std::complex< double > arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (std::complex< double > *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_std__complexT_double_t, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(s_1));
  arg2 = &vec__arg2;
  
  {
    arg3 = (double) scm_to_double(s_2);
  }
  {
    arg4 = (double) scm_to_double(s_3);
  }
  {
    arg5 = (double) scm_to_double(s_4);
  }
  
  meep::vec vec__arg6 = vector3_to_vec(ctl_convert_vector3_to_c(s_5));
  arg6 = &vec__arg6;
  
  {
    arg7 = (meep::component) scm_to_int(s_6); 
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_7);
    arg8 = std::complex<double>(cnum.re, cnum.im);
  }
  meep::green2d(arg1,(meep::vec const &)*arg2,arg3,arg4,arg5,(meep::vec const &)*arg6,arg7,arg8);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_green3d (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5, SCM s_6, SCM s_7)
{
#define FUNC_NAME "meep-green3d"
  std::complex< double > *arg1 = (std::complex< double > *) 0 ;
  meep::vec *arg2 = 0 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  meep::vec *arg6 = 0 ;
  meep::component arg7 ;
  std::complex< double > arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (std::complex< double > *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_std__complexT_double_t, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(s_1));
  arg2 = &vec__arg2;
  
  {
    arg3 = (double) scm_to_double(s_2);
  }
  {
    arg4 = (double) scm_to_double(s_3);
  }
  {
    arg5 = (double) scm_to_double(s_4);
  }
  
  meep::vec vec__arg6 = vector3_to_vec(ctl_convert_vector3_to_c(s_5));
  arg6 = &vec__arg6;
  
  {
    arg7 = (meep::component) scm_to_int(s_6); 
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_7);
    arg8 = std::complex<double>(cnum.re, cnum.im);
  }
  meep::green3d(arg1,(meep::vec const &)*arg2,arg3,arg4,arg5,(meep::vec const &)*arg6,arg7,arg8);
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_destroy_eigenmode_data__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-destroy-eigenmode-data"
  void *arg1 = (void *) 0 ;
  bool arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (void *)SWIG_MustGetPtr(argv[0], NULL, 1, 0);
  }
  {
    arg2 = (bool) scm_is_true(argv[1]);
  }
  meep::destroy_eigenmode_data(arg1,arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_destroy_eigenmode_data__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "meep-destroy-eigenmode-data"
  void *arg1 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (void *)SWIG_MustGetPtr(argv[0], NULL, 1, 0);
  }
  meep::destroy_eigenmode_data(arg1);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_destroy_eigenmode_data(SCM rest)
{
#define FUNC_NAME "meep-destroy-eigenmode-data"
  SCM argv[2];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 2, "meep-destroy-eigenmode-data");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_meep_destroy_eigenmode_data__SWIG_1(argc,argv);
    }
  }
  if (argc == 2) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        _v = SCM_BOOLP(argv[1]) ? 1 : 0;
      }
      if (_v) {
        return _wrap_meep_destroy_eigenmode_data__SWIG_0(argc,argv);
      }
    }
  }
  
  scm_misc_error("meep-destroy-eigenmode-data", "No matching method for generic function `meep_destroy_eigenmode_data'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_eigenmode_amplitude (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-eigenmode-amplitude"
  void *arg1 = (void *) 0 ;
  meep::vec *arg2 = 0 ;
  meep::component arg3 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  std::complex< double > result;
  
  {
    arg1 = (void *)SWIG_MustGetPtr(s_0, NULL, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(s_1));
  arg2 = &vec__arg2;
  
  {
    arg3 = (meep::component) scm_to_int(s_2); 
  }
  result = meep::eigenmode_amplitude(arg1,(meep::vec const &)*arg2,arg3);
  {
    gswig_result = scm_make_rectangular(ctl_convert_number_to_scm((&result)->real()),
      ctl_convert_number_to_scm((&result)->imag()));
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_get_group_velocity (SCM s_0)
{
#define FUNC_NAME "meep-get-group-velocity"
  void *arg1 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (void *)SWIG_MustGetPtr(s_0, NULL, 1, 0);
  }
  result = (double)meep::get_group_velocity(arg1);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_get_k (SCM s_0)
{
#define FUNC_NAME "meep-get-k"
  void *arg1 = (void *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = (void *)SWIG_MustGetPtr(s_0, NULL, 1, 0);
  }
  result = meep::get_k(arg1);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_linear_interpolate (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5, SCM s_6, SCM s_7)
{
#define FUNC_NAME "meep-linear-interpolate"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double *arg4 = (double *) 0 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  {
    arg4 = (double *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_double, 4, 0);
  }
  {
    arg5 = (int) scm_to_int(s_4);
  }
  {
    arg6 = (int) scm_to_int(s_5);
  }
  {
    arg7 = (int) scm_to_int(s_6);
  }
  {
    arg8 = (int) scm_to_int(s_7);
  }
  result = (double)meep::linear_interpolate(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_split_plane_dir_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "split-plane-dir-set"
  meep::split_plane *arg1 = (meep::split_plane *) 0 ;
  meep::direction arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::split_plane *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__split_plane, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  if (arg1) (arg1)->dir = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_split_plane_dir_get (SCM s_0)
{
#define FUNC_NAME "split-plane-dir-get"
  meep::split_plane *arg1 = (meep::split_plane *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::direction result;
  
  {
    arg1 = (meep::split_plane *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__split_plane, 1, 0);
  }
  result = (meep::direction) ((arg1)->dir);
  {
    gswig_result = scm_from_long((int)result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_split_plane_pos_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "split-plane-pos-set"
  meep::split_plane *arg1 = (meep::split_plane *) 0 ;
  double arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::split_plane *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__split_plane, 1, 0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  if (arg1) (arg1)->pos = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_split_plane_pos_get (SCM s_0)
{
#define FUNC_NAME "split-plane-pos-get"
  meep::split_plane *arg1 = (meep::split_plane *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  double result;
  
  {
    arg1 = (meep::split_plane *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__split_plane, 1, 0);
  }
  result = (double) ((arg1)->pos);
  {
    gswig_result = scm_from_double(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_split_plane ()
{
#define FUNC_NAME "new-split-plane"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::split_plane *result = 0 ;
  
  result = (meep::split_plane *)new meep::split_plane();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__split_plane, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_split_plane (SCM s_0)
{
#define FUNC_NAME "delete-split-plane"
  meep::split_plane *arg1 = (meep::split_plane *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::split_plane *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__split_plane, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_binary_partition__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-binary-partition"
  int arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::binary_partition *result = 0 ;
  
  {
    arg1 = (int) scm_to_int(argv[0]);
  }
  result = (meep::binary_partition *)new meep::binary_partition(arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__binary_partition, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_binary_partition__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-binary-partition"
  meep::split_plane *arg1 = 0 ;
  std::unique_ptr< meep::binary_partition > *arg2 = 0 ;
  std::unique_ptr< meep::binary_partition > *arg3 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::binary_partition *result = 0 ;
  
  {
    arg1 = (meep::split_plane *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__split_plane, 1, 0);
  }
  {
    arg2 = (std::unique_ptr< meep::binary_partition > *)SWIG_MustGetPtr(argv[1], SWIGTYPE_p_std__unique_ptrT_meep__binary_partition_t, 2, 0);
  }
  {
    arg3 = (std::unique_ptr< meep::binary_partition > *)SWIG_MustGetPtr(argv[2], SWIGTYPE_p_std__unique_ptrT_meep__binary_partition_t, 3, 0);
  }
  result = (meep::binary_partition *)new meep::binary_partition((meep::split_plane const &)*arg1,(std::unique_ptr< meep::binary_partition > &&)*arg2,(std::unique_ptr< meep::binary_partition > &&)*arg3);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__binary_partition, 1);
  }
  
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_binary_partition__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "new-meep-binary-partition"
  meep::binary_partition *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::binary_partition *result = 0 ;
  
  {
    arg1 = (meep::binary_partition *)SWIG_MustGetPtr(argv[0], SWIGTYPE_p_meep__binary_partition, 1, 0);
  }
  result = (meep::binary_partition *)new meep::binary_partition((meep::binary_partition const &)*arg1);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__binary_partition, 1);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_meep_binary_partition(SCM rest)
{
#define FUNC_NAME "new-meep-binary-partition"
  SCM argv[3];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 3, "new-meep-binary-partition");
  if (argc == 1) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__binary_partition, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_meep_binary_partition__SWIG_2(argc,argv);
    }
  }
  if (argc == 1) {
    int _v;
    {
      _v = scm_is_true(scm_integer_p(argv[0])) && scm_is_true(scm_exact_p(argv[0]))? 1 : 0;
    }
    if (_v) {
      return _wrap_new_meep_binary_partition__SWIG_0(argc,argv);
    }
  }
  if (argc == 3) {
    int _v;
    {
      void *ptr;
      int res = SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_meep__split_plane, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        void *ptr;
        int res = SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_std__unique_ptrT_meep__binary_partition_t, SWIG_POINTER_NO_NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          void *ptr;
          int res = SWIG_ConvertPtr(argv[2], &ptr, SWIGTYPE_p_std__unique_ptrT_meep__binary_partition_t, SWIG_POINTER_NO_NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_meep_binary_partition__SWIG_1(argc,argv);
        }
      }
    }
  }
  
  scm_misc_error("new-meep-binary-partition", "No matching method for generic function `new_meep_binary_partition'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_meep_binary_partition_is_leaf (SCM s_0)
{
#define FUNC_NAME "meep-binary-partition-is-leaf"
  meep::binary_partition *arg1 = (meep::binary_partition *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  bool result;
  
  {
    arg1 = (meep::binary_partition *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__binary_partition, 1, 0);
  }
  result = (bool)((meep::binary_partition const *)arg1)->is_leaf();
  {
    gswig_result = scm_from_bool(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_binary_partition_get_proc_id (SCM s_0)
{
#define FUNC_NAME "meep-binary-partition-get-proc-id"
  meep::binary_partition *arg1 = (meep::binary_partition *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  int result;
  
  {
    arg1 = (meep::binary_partition *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__binary_partition, 1, 0);
  }
  result = (int)((meep::binary_partition const *)arg1)->get_proc_id();
  {
    gswig_result = scm_from_long(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_binary_partition_get_plane (SCM s_0)
{
#define FUNC_NAME "meep-binary-partition-get-plane"
  meep::binary_partition *arg1 = (meep::binary_partition *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::split_plane *result = 0 ;
  
  {
    arg1 = (meep::binary_partition *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__binary_partition, 1, 0);
  }
  result = (meep::split_plane *) &((meep::binary_partition const *)arg1)->get_plane();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__split_plane, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_binary_partition_left_tree (SCM s_0)
{
#define FUNC_NAME "meep-binary-partition-left-tree"
  meep::binary_partition *arg1 = (meep::binary_partition *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::binary_partition *result = 0 ;
  
  {
    arg1 = (meep::binary_partition *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__binary_partition, 1, 0);
  }
  result = (meep::binary_partition *)((meep::binary_partition const *)arg1)->left_tree();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__binary_partition, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_binary_partition_right_tree (SCM s_0)
{
#define FUNC_NAME "meep-binary-partition-right-tree"
  meep::binary_partition *arg1 = (meep::binary_partition *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::binary_partition *result = 0 ;
  
  {
    arg1 = (meep::binary_partition *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__binary_partition, 1, 0);
  }
  result = (meep::binary_partition *)((meep::binary_partition const *)arg1)->right_tree();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__binary_partition, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_meep_binary_partition (SCM s_0)
{
#define FUNC_NAME "delete-meep-binary-partition"
  meep::binary_partition *arg1 = (meep::binary_partition *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (meep::binary_partition *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__binary_partition, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_set_zero_subnormals (SCM s_0)
{
#define FUNC_NAME "meep-set-zero-subnormals"
  bool arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (bool) scm_is_true(s_0);
  }
  meep::set_zero_subnormals(arg1);
  gswig_result = SCM_UNSPECIFIED;
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_setup ()
{
#define FUNC_NAME "meep-setup"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  meep::setup();
  gswig_result = SCM_UNSPECIFIED;
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_split_into_tiles (SCM s_0, SCM s_1, SCM s_2)
{
#define FUNC_NAME "meep-split-into-tiles"
  meep::grid_volume arg1 ;
  std::vector< meep::grid_volume > *arg2 = (std::vector< meep::grid_volume > *) 0 ;
  size_t arg3 ;
  meep::grid_volume *argp1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    argp1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
    arg1 = *argp1;
  }
  {
    arg2 = (std::vector< meep::grid_volume > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__vectorT_meep__grid_volume_t, 2, 0);
  }
  {
    arg3 = (size_t) scm_to_ulong(s_2);
  }
  meep::split_into_tiles(arg1,arg2,arg3);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_meep_check_tiles (SCM s_0, SCM s_1)
{
#define FUNC_NAME "meep-check-tiles"
  meep::grid_volume arg1 ;
  std::vector< meep::grid_volume > *arg2 = 0 ;
  meep::grid_volume *argp1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    argp1 = (meep::grid_volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__grid_volume, 1, 0);
    arg1 = *argp1;
  }
  {
    arg2 = (std::vector< meep::grid_volume > *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_std__vectorT_meep__grid_volume_t, 2, 0);
  }
  meep::check_tiles(arg1,(std::vector< meep::grid_volume > const &)*arg2);
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_MEEP_CTL_SWIG_HPP(SCM s_0)
{
#define FUNC_NAME "MEEP-CTL-SWIG-HPP"
  SCM gswig_result;
  
  {
    gswig_result = scm_from_long(gswig_const_MEEP_CTL_SWIG_HPP);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_kpoint_list_kpoints_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "kpoint-list-kpoints-set"
  kpoint_list *arg1 = (kpoint_list *) 0 ;
  meep::vec *arg2 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (kpoint_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_kpoint_list, 1, 0);
  }
  {
    arg2 = (meep::vec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__vec, 2, 0);
  }
  if (arg1) (arg1)->kpoints = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_kpoint_list_kpoints_get (SCM s_0)
{
#define FUNC_NAME "kpoint-list-kpoints-get"
  kpoint_list *arg1 = (kpoint_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec *result = 0 ;
  
  {
    arg1 = (kpoint_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_kpoint_list, 1, 0);
  }
  result = (meep::vec *) ((arg1)->kpoints);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__vec, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_kpoint_list_n_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "kpoint-list-n-set"
  kpoint_list *arg1 = (kpoint_list *) 0 ;
  size_t arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (kpoint_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_kpoint_list, 1, 0);
  }
  {
    arg2 = (size_t) scm_to_ulong(s_1);
  }
  if (arg1) (arg1)->n = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_kpoint_list_n_get (SCM s_0)
{
#define FUNC_NAME "kpoint-list-n-get"
  kpoint_list *arg1 = (kpoint_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  size_t result;
  
  {
    arg1 = (kpoint_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_kpoint_list, 1, 0);
  }
  result =  ((arg1)->n);
  {
    gswig_result = scm_from_ulong(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_kpoint_list_kdom_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "kpoint-list-kdom-set"
  kpoint_list *arg1 = (kpoint_list *) 0 ;
  meep::vec *arg2 = (meep::vec *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (kpoint_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_kpoint_list, 1, 0);
  }
  {
    arg2 = (meep::vec *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__vec, 2, 0);
  }
  if (arg1) (arg1)->kdom = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_kpoint_list_kdom_get (SCM s_0)
{
#define FUNC_NAME "kpoint-list-kdom-get"
  kpoint_list *arg1 = (kpoint_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec *result = 0 ;
  
  {
    arg1 = (kpoint_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_kpoint_list, 1, 0);
  }
  result = (meep::vec *) ((arg1)->kdom);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__vec, 0);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_kpoint_list_num_bands_set (SCM s_0, SCM s_1)
{
#define FUNC_NAME "kpoint-list-num-bands-set"
  kpoint_list *arg1 = (kpoint_list *) 0 ;
  size_t arg2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (kpoint_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_kpoint_list, 1, 0);
  }
  {
    arg2 = (size_t) scm_to_ulong(s_1);
  }
  if (arg1) (arg1)->num_bands = arg2;
  gswig_result = SCM_UNSPECIFIED;
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_kpoint_list_num_bands_get (SCM s_0)
{
#define FUNC_NAME "kpoint-list-num-bands-get"
  kpoint_list *arg1 = (kpoint_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  size_t result;
  
  {
    arg1 = (kpoint_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_kpoint_list, 1, 0);
  }
  result =  ((arg1)->num_bands);
  {
    gswig_result = scm_from_ulong(result);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_new_kpoint_list ()
{
#define FUNC_NAME "new-kpoint-list"
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  kpoint_list *result = 0 ;
  
  result = (kpoint_list *)new kpoint_list();
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_kpoint_list, 1);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_delete_kpoint_list (SCM s_0)
{
#define FUNC_NAME "delete-kpoint-list"
  kpoint_list *arg1 = (kpoint_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (kpoint_list *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_kpoint_list, 1, 0);
  }
  delete arg1;
  gswig_result = SCM_UNSPECIFIED;
  
  SWIG_Guile_MarkPointerDestroyed(s_0);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_vec_to_vector3 (SCM s_0)
{
#define FUNC_NAME "vec-to-vector3"
  meep::vec *arg1 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  vector3 result;
  
  
  meep::vec vec__arg1 = vector3_to_vec(ctl_convert_vector3_to_c(s_0));
  arg1 = &vec__arg1;
  
  result = vec_to_vector3((meep::vec const &)*arg1);
  {
    gswig_result = ctl_convert_vector3_to_scm(result); 
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_vector3_to_vec (SCM s_0)
{
#define FUNC_NAME "vector3-to-vec"
  vector3 arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::vec result;
  
  {
    arg1 = ctl_convert_vector3_to_c(s_0); 
  }
  result = vector3_to_vec(arg1);
  {
    gswig_result = ctl_convert_vector3_to_scm(vec_to_vector3(result));
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_set_dimensions (SCM s_0)
{
#define FUNC_NAME "set-dimensions"
  int arg1 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  
  {
    arg1 = (int) scm_to_int(s_0);
  }
  set_dimensions(arg1);
  gswig_result = SCM_UNSPECIFIED;
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_make_structure (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5, SCM s_6, SCM s_7, SCM s_8, SCM s_9, SCM s_10, SCM s_11, SCM s_12, SCM s_13, SCM s_14, SCM s_15, SCM s_16, SCM s_17)
{
#define FUNC_NAME "make-structure"
  int arg1 ;
  vector3 arg2 ;
  vector3 arg3 ;
  double arg4 ;
  bool arg5 ;
  double arg6 ;
  int arg7 ;
  bool arg8 ;
  ctlio::geometric_object_list arg9 ;
  ctlio::material_type_list arg10 ;
  ctlio::material_type arg11 ;
  char *arg12 = (char *) 0 ;
  ctlio::pml_list arg13 ;
  ctlio::symmetry_list arg14 ;
  int arg15 ;
  double arg16 ;
  double arg17 ;
  double arg18 ;
  int must_free12 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::structure *result = 0 ;
  
  {
    arg1 = (int) scm_to_int(s_0);
  }
  {
    arg2 = ctl_convert_vector3_to_c(s_1); 
  }
  {
    arg3 = ctl_convert_vector3_to_c(s_2); 
  }
  {
    arg4 = (double) scm_to_double(s_3);
  }
  {
    arg5 = (bool) scm_is_true(s_4);
  }
  {
    arg6 = (double) scm_to_double(s_5);
  }
  {
    arg7 = (int) scm_to_int(s_6);
  }
  {
    arg8 = (bool) scm_is_true(s_7);
  }
  {
    using namespace ctlio;
    {
      list lo_t = ctl_convert_list_to_c(s_8);
      int i_t;
      (&arg9)->num_items = list_length(lo_t);
      (&arg9)->items = (new geometric_object[(&arg9)->num_items]);
      for (i_t = 0; i_t < (&arg9)->num_items; i_t++) {
        geometric_object_input(object_list_ref(lo_t, i_t), &(&arg9)->items[i_t]);
      }
    }
  }
  {
    using namespace ctlio;
    {
      list lo_t = ctl_convert_list_to_c(s_9);
      int i_t;
      (&arg10)->num_items = list_length(lo_t);
      (&arg10)->items = (new material_type[(&arg10)->num_items]);
      for (i_t = 0; i_t < (&arg10)->num_items; i_t++) {
        material_type_input(object_list_ref(lo_t, i_t), &(&arg10)->items[i_t]);
      }
    }
  }
  {
    using namespace ctlio;
    material_type_input(ctl_convert_object_to_c(s_10), &arg11);
  }
  {
    arg12 = (char *)SWIG_scm2str(s_11);
    must_free12 = 1;
  }
  {
    using namespace ctlio;
    {
      list lo_t = ctl_convert_list_to_c(s_12);
      int i_t;
      (&arg13)->num_items = list_length(lo_t);
      (&arg13)->items = (new pml[(&arg13)->num_items]);
      for (i_t = 0; i_t < (&arg13)->num_items; i_t++) {
        pml_input(object_list_ref(lo_t, i_t), &(&arg13)->items[i_t]);
      }
    }
  }
  {
    using namespace ctlio;
    {
      list lo_t = ctl_convert_list_to_c(s_13);
      int i_t;
      (&arg14)->num_items = list_length(lo_t);
      (&arg14)->items = (new symmetry[(&arg14)->num_items]);
      for (i_t = 0; i_t < (&arg14)->num_items; i_t++) {
        symmetry_input(object_list_ref(lo_t, i_t), &(&arg14)->items[i_t]);
      }
    }
  }
  {
    arg15 = (int) scm_to_int(s_14);
  }
  {
    arg16 = (double) scm_to_double(s_15);
  }
  {
    arg17 = (double) scm_to_double(s_16);
  }
  {
    arg18 = (double) scm_to_double(s_17);
  }
  result = (meep::structure *)make_structure(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,(char const *)arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__structure, 0);
  }
  if (must_free12 && arg12) SWIG_free(arg12);
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_make_structure_rest (SCM rest)
{
SCM arg[18];
SWIG_Guile_GetArgs (arg, rest, 18, 0, "make-structure");
return _wrap_make_structure(arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9], arg[10], arg[11], arg[12], arg[13], arg[14], arg[15], arg[16], arg[17]);
}
static SCM
_wrap_do_harminv (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5, SCM s_6, SCM s_7, SCM s_8, SCM s_9, SCM s_10)
{
#define FUNC_NAME "do-harminv"
  ctlio::cnumber_list arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int arg5 ;
  double arg6 ;
  double arg7 ;
  double arg8 ;
  double arg9 ;
  double arg10 ;
  double arg11 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::cvector3_list result;
  
  {
    using namespace ctlio;
    {
      list lo_t = ctl_convert_list_to_c(s_0);
      int i_t;
      (&arg1)->num_items = list_length(lo_t);
      (&arg1)->items = (new cnumber[(&arg1)->num_items]);
      for (i_t = 0; i_t < (&arg1)->num_items; i_t++) {
        (&arg1)->items[i_t] = cnumber_list_ref(lo_t, i_t);
      }
    }
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  {
    arg4 = (double) scm_to_double(s_3);
  }
  {
    arg5 = (int) scm_to_int(s_4);
  }
  {
    arg6 = (double) scm_to_double(s_5);
  }
  {
    arg7 = (double) scm_to_double(s_6);
  }
  {
    arg8 = (double) scm_to_double(s_7);
  }
  {
    arg9 = (double) scm_to_double(s_8);
  }
  {
    arg10 = (double) scm_to_double(s_9);
  }
  {
    arg11 = (double) scm_to_double(s_10);
  }
  result = do_harminv(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_cvector3_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_do_harminv_rest (SCM rest)
{
SCM arg[11];
SWIG_Guile_GetArgs (arg, rest, 11, 0, "do-harminv");
return _wrap_do_harminv(arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9], arg[10]);
}
static SCM
_wrap_do_get_eigenmode_coefficients (SCM s_0, SCM s_1, SCM s_2, SCM s_3, SCM s_4, SCM s_5, SCM s_6, SCM s_7, SCM s_8, SCM s_9, SCM s_10)
{
#define FUNC_NAME "do-get-eigenmode-coefficients"
  meep::fields *arg1 = (meep::fields *) 0 ;
  SwigValueWrapper< meep::dft_flux > arg2 ;
  meep::volume *arg3 = 0 ;
  int *arg4 = (int *) 0 ;
  int arg5 ;
  int arg6 ;
  std::complex< double > *arg7 = (std::complex< double > *) 0 ;
  double *arg8 = (double *) 0 ;
  double arg9 ;
  double arg10 ;
  meep::kpoint_func arg11 = (meep::kpoint_func) 0 ;
  void *arg12 = (void *) 0 ;
  int arg13 ;
  meep::dft_flux *argp2 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  kpoint_list result;
  
  {
    arg1 = (meep::fields *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__fields, 1, 0);
  }
  {
    argp2 = (meep::dft_flux *)SWIG_MustGetPtr(s_1, SWIGTYPE_p_meep__dft_flux, 2, 0);
    arg2 = *argp2;
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg5 = list_length(s_3);
    arg4 = new int[arg5];
    
    for (int i = 0; i < arg5; ++i) {
      arg4[i] = integer_list_ref(s_3, i);
    }
  }
  {
    arg6 = (int) scm_to_int(s_4);
  }
  scm_t_array_handle coeffs_handle;
  scm_array_get_handle(s_5, &coeffs_handle);
  arg7 = (std::complex<double>*)scm_array_handle_uniform_writable_elements(&coeffs_handle);
  scm_t_array_handle vgrp_handle;
  scm_array_get_handle(s_6, &vgrp_handle);
  arg8 = (double*)scm_array_handle_uniform_writable_elements(&vgrp_handle);
  {
    arg9 = (double) scm_to_double(s_7);
  }
  {
    arg10 = (double) scm_to_double(s_8);
  }
  {
    if (SCM_NFALSEP(scm_procedure_p(s_9))) {
      arg11 = my_kpoint_func;
      arg12 = (void*)s_9;
    }
    else {
      arg11 = NULL;
      arg12 = NULL;
    }
  }
  {
    arg13 = (int) scm_to_int(s_10);
  }
  result = do_get_eigenmode_coefficients(arg1,arg2,(meep::volume const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    int i;
    list kpoint_list = SCM_EOL;
    list kdom_list = SCM_EOL;
    for (i = (&result)->n - 1; i >= 0; --i) {
      kpoint_list = gh_cons(vector32scm(vec_to_vector3((&result)->kpoints[i])), kpoint_list);
    }
    for (i = (&result)->num_bands - 1; i >= 0; --i) {
      kdom_list = gh_cons(vector32scm(vec_to_vector3((&result)->kdom[i])), kdom_list);
    }
    
    gswig_result = scm_list_2(kpoint_list, kdom_list);
    
    delete[] (&result)->kpoints;
    delete[] (&result)->kdom;
  }
  
  
  {
    if (arg4) {
      delete[] arg4;
    }
  }
  {
    scm_array_handle_release(&coeffs_handle);
  }
  {
    scm_array_handle_release(&vgrp_handle);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_do_get_eigenmode_coefficients_rest (SCM rest)
{
SCM arg[11];
SWIG_Guile_GetArgs (arg, rest, 11, 0, "do-get-eigenmode-coefficients");
return _wrap_do_get_eigenmode_coefficients(arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9], arg[10]);
}
static SCM
_wrap_dft_flux_flux (SCM s_0)
{
#define FUNC_NAME "dft-flux-flux"
  meep::dft_flux *arg1 = (meep::dft_flux *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::number_list result;
  
  {
    arg1 = (meep::dft_flux *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_flux, 1, 0);
  }
  result = dft_flux_flux(arg1);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_number_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_dft_energy_electric (SCM s_0)
{
#define FUNC_NAME "dft-energy-electric"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::number_list result;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  result = dft_energy_electric(arg1);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_number_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_dft_energy_magnetic (SCM s_0)
{
#define FUNC_NAME "dft-energy-magnetic"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::number_list result;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  result = dft_energy_magnetic(arg1);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_number_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_dft_energy_total (SCM s_0)
{
#define FUNC_NAME "dft-energy-total"
  meep::dft_energy *arg1 = (meep::dft_energy *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::number_list result;
  
  {
    arg1 = (meep::dft_energy *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_energy, 1, 0);
  }
  result = dft_energy_total(arg1);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_number_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_dft_force_force (SCM s_0)
{
#define FUNC_NAME "dft-force-force"
  meep::dft_force *arg1 = (meep::dft_force *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::number_list result;
  
  {
    arg1 = (meep::dft_force *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_force, 1, 0);
  }
  result = dft_force_force(arg1);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_number_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_dft_ldos_ldos (SCM s_0)
{
#define FUNC_NAME "dft-ldos-ldos"
  meep::dft_ldos *arg1 = (meep::dft_ldos *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::number_list result;
  
  {
    arg1 = (meep::dft_ldos *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_ldos, 1, 0);
  }
  result = dft_ldos_ldos(arg1);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_number_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_dft_ldos_F (SCM s_0)
{
#define FUNC_NAME "dft-ldos-F"
  meep::dft_ldos *arg1 = (meep::dft_ldos *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::cnumber_list result;
  
  {
    arg1 = (meep::dft_ldos *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_ldos, 1, 0);
  }
  result = dft_ldos_F(arg1);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_cnumber_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_dft_ldos_J (SCM s_0)
{
#define FUNC_NAME "dft-ldos-J"
  meep::dft_ldos *arg1 = (meep::dft_ldos *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::cnumber_list result;
  
  {
    arg1 = (meep::dft_ldos *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_ldos, 1, 0);
  }
  result = dft_ldos_J(arg1);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_cnumber_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_dft_near2far_farfield (SCM s_0, SCM s_1)
{
#define FUNC_NAME "dft-near2far-farfield"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::vec *arg2 = 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::cnumber_list result;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  
  meep::vec vec__arg2 = vector3_to_vec(ctl_convert_vector3_to_c(s_1));
  arg2 = &vec__arg2;
  
  result = dft_near2far_farfield(arg1,(meep::vec const &)*arg2);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_cnumber_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_dft_near2far_flux (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "dft-near2far-flux"
  meep::dft_near2far *arg1 = (meep::dft_near2far *) 0 ;
  meep::direction arg2 ;
  meep::volume *arg3 = 0 ;
  double arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::number_list result;
  
  {
    arg1 = (meep::dft_near2far *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__dft_near2far, 1, 0);
  }
  {
    arg2 = (meep::direction) scm_to_int(s_1); 
  }
  {
    arg3 = (meep::volume *)SWIG_MustGetPtr(s_2, SWIGTYPE_p_meep__volume, 3, 0);
  }
  {
    arg4 = (double) scm_to_double(s_3);
  }
  result = dft_near2far_flux(arg1,arg2,(meep::volume const &)*arg3,arg4);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_number_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_make_casimir_g__SWIG_0 (int argc, SCM *argv)
{
#define FUNC_NAME "make-casimir-g"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  meep::field_type arg4 ;
  std::complex< double > (*arg5)(std::complex< double >) = (std::complex< double > (*)(std::complex< double >)) 0 ;
  double arg6 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::cnumber_list result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (meep::field_type) scm_to_int(argv[3]); 
  }
  {
    my_complex_func3_scm = argv[4];
    arg5 = my_complex_func3;
  }
  {
    arg6 = (double) scm_to_double(argv[5]);
  }
  result = make_casimir_g(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_cnumber_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_make_casimir_g__SWIG_1 (int argc, SCM *argv)
{
#define FUNC_NAME "make-casimir-g"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  meep::field_type arg4 ;
  std::complex< double > (*arg5)(std::complex< double >) = (std::complex< double > (*)(std::complex< double >)) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::cnumber_list result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (meep::field_type) scm_to_int(argv[3]); 
  }
  {
    my_complex_func3_scm = argv[4];
    arg5 = my_complex_func3;
  }
  result = make_casimir_g(arg1,arg2,arg3,arg4,arg5);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_cnumber_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_make_casimir_g__SWIG_2 (int argc, SCM *argv)
{
#define FUNC_NAME "make-casimir-g"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  meep::field_type arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::cnumber_list result;
  
  {
    arg1 = (double) scm_to_double(argv[0]);
  }
  {
    arg2 = (double) scm_to_double(argv[1]);
  }
  {
    arg3 = (double) scm_to_double(argv[2]);
  }
  {
    arg4 = (meep::field_type) scm_to_int(argv[3]); 
  }
  result = make_casimir_g(arg1,arg2,arg3,arg4);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_cnumber_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_make_casimir_g(SCM rest)
{
#define FUNC_NAME "make-casimir-g"
  SCM argv[6];
  int argc = SWIG_Guile_GetArgs (argv, rest, 0, 6, "make-casimir-g");
  if (argc == 4) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            return _wrap_make_casimir_g__SWIG_2(argc,argv);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_NFALSEP(scm_procedure_p(argv[4]));
            }
            if (_v) {
              return _wrap_make_casimir_g__SWIG_1(argc,argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      _v = scm_is_true(scm_real_p(argv[0])) ? 1 : 0;
    }
    if (_v) {
      {
        _v = scm_is_true(scm_real_p(argv[1])) ? 1 : 0;
      }
      if (_v) {
        {
          _v = scm_is_true(scm_real_p(argv[2])) ? 1 : 0;
        }
        if (_v) {
          {
            _v = scm_is_true(scm_integer_p(argv[3])) && scm_is_true(scm_exact_p(argv[3]))? 1 : 0;
          }
          if (_v) {
            {
              _v = SCM_NFALSEP(scm_procedure_p(argv[4]));
            }
            if (_v) {
              {
                _v = scm_is_true(scm_real_p(argv[5])) ? 1 : 0;
              }
              if (_v) {
                return _wrap_make_casimir_g__SWIG_0(argc,argv);
              }
            }
          }
        }
      }
    }
  }
  
  scm_misc_error("make-casimir-g", "No matching method for generic function `make_casimir_g'", SCM_EOL);
#undef FUNC_NAME
}


static SCM
_wrap_make_casimir_g_kz (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "make-casimir-g-kz"
  double arg1 ;
  double arg2 ;
  double arg3 ;
  meep::field_type arg4 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::cnumber_list result;
  
  {
    arg1 = (double) scm_to_double(s_0);
  }
  {
    arg2 = (double) scm_to_double(s_1);
  }
  {
    arg3 = (double) scm_to_double(s_2);
  }
  {
    arg4 = (meep::field_type) scm_to_int(s_3); 
  }
  result = make_casimir_g_kz(arg1,arg2,arg3,arg4);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_cnumber_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_make_volume_list (SCM s_0, SCM s_1, SCM s_2, SCM s_3)
{
#define FUNC_NAME "make-volume-list"
  meep::volume *arg1 = 0 ;
  int arg2 ;
  std::complex< double > arg3 ;
  meep::volume_list *arg4 = (meep::volume_list *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  meep::volume_list *result = 0 ;
  
  {
    arg1 = (meep::volume *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_meep__volume, 1, 0);
  }
  {
    arg2 = (int) scm_to_int(s_1);
  }
  {
    cnumber cnum = ctl_convert_cnumber_to_c(s_2);
    arg3 = std::complex<double>(cnum.re, cnum.im);
  }
  {
    arg4 = (meep::volume_list *)SWIG_MustGetPtr(s_3, SWIGTYPE_p_meep__volume_list, 4, 0);
  }
  result = (meep::volume_list *)make_volume_list((meep::volume const &)*arg1,arg2,arg3,arg4);
  {
    gswig_result = SWIG_NewPointerObj (result, SWIGTYPE_p_meep__volume_list, 0);
  }
  
  
  
  return gswig_result;
#undef FUNC_NAME
}


static SCM
_wrap_std_vector_double_to_scm (SCM s_0)
{
#define FUNC_NAME "std-vector-double-to-scm"
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  SCM gswig_result;
  SWIGUNUSED int gswig_list_p = 0;
  ctlio::number_list result;
  
  {
    arg1 = (std::vector< double > *)SWIG_MustGetPtr(s_0, SWIGTYPE_p_std__vectorT_double_t, 1, 0);
  }
  result = std_vector_double_to_scm(arg1);
  {
    using namespace ctlio;
    gswig_result = ctl_convert_list_to_scm(make_number_list((&result)->num_items, (&result)->items));
    {
      int index_t;
      for (index_t = 0; index_t < (&result)->num_items; index_t++) {
        
      }
    }
    delete[] ((&result)->items);
  }
  
  
  return gswig_result;
#undef FUNC_NAME
}


#ifdef __cplusplus
extern "C" {
#endif

/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_p_meep__lorentzian_susceptibilityTo_p_p_meep__susceptibility(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::susceptibility **)  ((meep::lorentzian_susceptibility **) x));
}
static void *_p_p_meep__noisy_lorentzian_susceptibilityTo_p_p_meep__susceptibility(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::susceptibility **) (meep::lorentzian_susceptibility *) ((meep::noisy_lorentzian_susceptibility **) x));
}
static void *_p_p_meep__gyrotropic_susceptibilityTo_p_p_meep__susceptibility(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::susceptibility **)  ((meep::gyrotropic_susceptibility **) x));
}
static void *_p_p_meep__multilevel_susceptibilityTo_p_p_meep__susceptibility(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::susceptibility **)  ((meep::multilevel_susceptibility **) x));
}
static void *_p_meep__lorentzian_susceptibilityTo_p_meep__susceptibility(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::susceptibility *)  ((meep::lorentzian_susceptibility *) x));
}
static void *_p_meep__noisy_lorentzian_susceptibilityTo_p_meep__susceptibility(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::susceptibility *) (meep::lorentzian_susceptibility *) ((meep::noisy_lorentzian_susceptibility *) x));
}
static void *_p_meep__gyrotropic_susceptibilityTo_p_meep__susceptibility(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::susceptibility *)  ((meep::gyrotropic_susceptibility *) x));
}
static void *_p_meep__multilevel_susceptibilityTo_p_meep__susceptibility(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::susceptibility *)  ((meep::multilevel_susceptibility *) x));
}
static void *_p_meep__noisy_lorentzian_susceptibilityTo_p_meep__lorentzian_susceptibility(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::lorentzian_susceptibility *)  ((meep::noisy_lorentzian_susceptibility *) x));
}
static void *_p_meep__simple_material_functionTo_p_meep__material_function(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::material_function *)  ((meep::simple_material_function *) x));
}
static void *_p_meep__gaussian_src_timeTo_p_meep__src_time(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::src_time *)  ((meep::gaussian_src_time *) x));
}
static void *_p_meep__continuous_src_timeTo_p_meep__src_time(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::src_time *)  ((meep::continuous_src_time *) x));
}
static void *_p_meep__custom_src_timeTo_p_meep__src_time(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::src_time *)  ((meep::custom_src_time *) x));
}
static void *_p_p_meep__gaussian_src_timeTo_p_p_meep__src_time(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::src_time **)  ((meep::gaussian_src_time **) x));
}
static void *_p_p_meep__continuous_src_timeTo_p_p_meep__src_time(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::src_time **)  ((meep::continuous_src_time **) x));
}
static void *_p_p_meep__custom_src_timeTo_p_p_meep__src_time(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((meep::src_time **)  ((meep::custom_src_time **) x));
}
static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_2__p_double = {"_p_a_2__p_double", "double *(*)[2]|meep::realnum *(*)[2]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_5__bool = {"_p_a_5__bool", "bool (*)[5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_5__meep__boundary_condition = {"_p_a_5__meep__boundary_condition", "enum meep::boundary_condition (*)[5]|meep::boundary_condition (*)[5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_5__p_double = {"_p_a_5__p_double", "double *(*)[5]|meep::realnum *(*)[5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_9__std__complexT_double_t = {"_p_a_9__std__complexT_double_t", "std::complex< double > (*)[9]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_access_mode = {"_p_access_mode", "access_mode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_boundary_region_kind = {"_p_boundary_region_kind", "boundary_region_kind *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ctlio__cnumber_list = {"_p_ctlio__cnumber_list", "ctlio::cnumber_list *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ctlio__geometric_object_list = {"_p_ctlio__geometric_object_list", "ctlio::geometric_object_list *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ctlio__material_type = {"_p_ctlio__material_type", "ctlio::material_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ctlio__material_type_list = {"_p_ctlio__material_type_list", "ctlio::material_type_list *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ctlio__pml_list = {"_p_ctlio__pml_list", "ctlio::pml_list *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ctlio__symmetry_list = {"_p_ctlio__symmetry_list", "ctlio::symmetry_list *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "meep::realnum *|double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_double_int_p_void__meep__vec = {"_p_f_double_int_p_void__meep__vec", "meep::kpoint_func|meep::vec (*)(double,int,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_double_p_void__double = {"_p_f_double_p_void__double", "double (*)(double,void *)|meep::pml_profile_func", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void = {"_p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void", "void (*)(meep::fields_chunk *,int,enum meep::component,meep::ivec,meep::ivec,meep::vec,meep::vec,meep::vec,meep::vec,double,double,meep::ivec,std::complex< double >,meep::symmetry const &,int,void *)|meep::field_chunkloop", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__char__void = {"_p_f_p_q_const__char__void", "void (*)(char const *)|meep::meep_printf_callback_func", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double = {"_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double", "double (*)(std::complex< double > const *,meep::vec const &,void *)|meep::field_rfunction", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t = {"_p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t", "meep::field_function|std::complex< double > (*)(std::complex< double > const *,meep::vec const &,void *)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_f_r_q_const__meep__vec__double = {"_p_f_r_q_const__meep__vec__double", "double (*)(meep::vec const &)", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_kpoint_list = {"_p_kpoint_list", "kpoint_list *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long_double = {"_p_long_double", "long double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__binary_partition = {"_p_meep__binary_partition", "meep::binary_partition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__boundary_region = {"_p_meep__boundary_region", "meep::boundary_region *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__chunkloop_field_components = {"_p_meep__chunkloop_field_components", "meep::chunkloop_field_components *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__component = {"_p_meep__component", "enum meep::component *|meep::component *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__continuous_src_time = {"_p_meep__continuous_src_time", "meep::continuous_src_time *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__custom_src_time = {"_p_meep__custom_src_time", "meep::custom_src_time *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__dft_chunk = {"_p_meep__dft_chunk", "meep::dft_chunk *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__dft_energy = {"_p_meep__dft_energy", "meep::dft_energy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__dft_fields = {"_p_meep__dft_fields", "meep::dft_fields *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__dft_flux = {"_p_meep__dft_flux", "meep::dft_flux *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__dft_force = {"_p_meep__dft_force", "meep::dft_force *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__dft_ldos = {"_p_meep__dft_ldos", "meep::dft_ldos *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__dft_near2far = {"_p_meep__dft_near2far", "meep::dft_near2far *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__diffractedplanewave = {"_p_meep__diffractedplanewave", "meep::diffractedplanewave *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__direction = {"_p_meep__direction", "enum meep::direction *|meep::direction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__fields = {"_p_meep__fields", "meep::fields *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__fields_chunk = {"_p_meep__fields_chunk", "meep::fields_chunk *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__flux_vol = {"_p_meep__flux_vol", "meep::flux_vol *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__gaussian_src_time = {"_p_meep__gaussian_src_time", "meep::gaussian_src_time *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__gaussianbeam = {"_p_meep__gaussianbeam", "meep::gaussianbeam *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__grid_volume = {"_p_meep__grid_volume", "meep::grid_volume *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__gyrotropic_susceptibility = {"_p_meep__gyrotropic_susceptibility", "meep::gyrotropic_susceptibility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__gyrotropy_model = {"_p_meep__gyrotropy_model", "enum meep::gyrotropy_model *|meep::gyrotropy_model *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__h5file = {"_p_meep__h5file", "meep::h5file *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__h5file__extending_s = {"_p_meep__h5file__extending_s", "meep::h5file::extending_s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__initialize = {"_p_meep__initialize", "meep::initialize *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__ivec = {"_p_meep__ivec", "meep::ivec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__lorentzian_susceptibility = {"_p_meep__lorentzian_susceptibility", "meep::lorentzian_susceptibility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__material_function = {"_p_meep__material_function", "meep::material_function *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__monitor_point = {"_p_meep__monitor_point", "meep::monitor_point *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__multilevel_susceptibility = {"_p_meep__multilevel_susceptibility", "meep::multilevel_susceptibility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__noisy_lorentzian_susceptibility = {"_p_meep__noisy_lorentzian_susceptibility", "meep::noisy_lorentzian_susceptibility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__polarization_state_s = {"_p_meep__polarization_state_s", "meep::polarization_state_s *|meep::polarization_state *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__signed_direction = {"_p_meep__signed_direction", "meep::signed_direction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__simple_material_function = {"_p_meep__simple_material_function", "meep::simple_material_function *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__sourcedata = {"_p_meep__sourcedata", "meep::sourcedata *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__split_plane = {"_p_meep__split_plane", "meep::split_plane *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__src_time = {"_p_meep__src_time", "meep::src_time *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__structure = {"_p_meep__structure", "meep::structure *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__structure_chunk = {"_p_meep__structure_chunk", "meep::structure_chunk *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__susceptibility = {"_p_meep__susceptibility", "meep::susceptibility *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__symmetry = {"_p_meep__symmetry", "meep::symmetry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__timing_scope = {"_p_meep__timing_scope", "meep::timing_scope *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__vec = {"_p_meep__vec", "meep::vec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__volume = {"_p_meep__volume", "meep::volume *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_meep__volume_list = {"_p_meep__volume_list", "meep::volume_list *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_double = {"_p_p_double", "meep::realnum **|double **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_meep__dft_chunk = {"_p_p_meep__dft_chunk", "meep::dft_chunk **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_meep__fields_chunk = {"_p_p_meep__fields_chunk", "meep::fields_chunk **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_meep__src_time = {"_p_p_meep__src_time", "meep::src_time **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_meep__gaussian_src_time = {"_p_p_meep__gaussian_src_time", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_meep__continuous_src_time = {"_p_p_meep__continuous_src_time", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_meep__custom_src_time = {"_p_p_meep__custom_src_time", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_meep__structure_chunk = {"_p_p_meep__structure_chunk", "meep::structure_chunk **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_meep__susceptibility = {"_p_p_meep__susceptibility", "meep::susceptibility **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_meep__lorentzian_susceptibility = {"_p_p_meep__lorentzian_susceptibility", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_meep__noisy_lorentzian_susceptibility = {"_p_p_meep__noisy_lorentzian_susceptibility", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_meep__gyrotropic_susceptibility = {"_p_p_meep__gyrotropic_susceptibility", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_meep__multilevel_susceptibility = {"_p_p_meep__multilevel_susceptibility", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_p_char = {"_p_p_p_char", "char ***", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_std__complexT_double_t = {"_p_p_std__complexT_double_t", "std::complex< meep::realnum > **|std::complex< double > **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ptrdiff_t = {"_p_ptrdiff_t", "ptrdiff_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__complexT_double_t = {"_p_std__complexT_double_t", "std::complex< meep::realnum > *|std::complex< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__complexT_float_t = {"_p_std__complexT_float_t", "std::complex< float > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__complexT_long_double_t = {"_p_std__complexT_long_double_t", "std::complex< long double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_int_int_t = {"_p_std__pairT_int_int_t", "std::pair< int,int > *|meep::chunk_pair *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unique_ptrT_meep__binary_partition_t = {"_p_std__unique_ptrT_meep__binary_partition_t", "std::unique_ptr< meep::binary_partition > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unordered_mapT_meep__time_sink_double_std__hashT_int_t_t = {"_p_std__unordered_mapT_meep__time_sink_double_std__hashT_int_t_t", "meep::time_sink_to_duration_map *|std::unordered_map< enum meep::time_sink,double,std::hash< int > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__unordered_mapT_meep__time_sink_std__vectorT_double_t_std__hashT_int_t_t = {"_p_std__unordered_mapT_meep__time_sink_std__vectorT_double_t_std__hashT_int_t_t", "std::unordered_map< meep::time_sink,std::vector< double >,std::hash< int > > *|std::unordered_map< enum meep::time_sink,std::vector< double >,std::hash< int > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_double_t = {"_p_std__vectorT_double_t", "std::vector< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_int_t = {"_p_std__vectorT_int_t", "std::vector< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_meep__component_t = {"_p_std__vectorT_meep__component_t", "std::vector< enum meep::component > *|std::vector< meep::component > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_meep__grid_volume_t = {"_p_std__vectorT_meep__grid_volume_t", "std::vector< meep::grid_volume > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_meep__sourcedata_t = {"_p_std__vectorT_meep__sourcedata_t", "std::vector< meep::sourcedata > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_ptrdiff_t_t = {"_p_std__vectorT_ptrdiff_t_t", "std::vector< ptrdiff_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_size_t_t = {"_p_std__vectorT_size_t_t", "std::vector< size_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__complexT_double_t_t = {"_p_std__vectorT_std__complexT_double_t_t", "std::vector< std::complex< double > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "SCM *|unsigned long *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vector3 = {"_p_vector3", "vector3 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_FILE,
  &_swigt__p_a_2__p_double,
  &_swigt__p_a_5__bool,
  &_swigt__p_a_5__meep__boundary_condition,
  &_swigt__p_a_5__p_double,
  &_swigt__p_a_9__std__complexT_double_t,
  &_swigt__p_access_mode,
  &_swigt__p_bool,
  &_swigt__p_boundary_region_kind,
  &_swigt__p_ctlio__cnumber_list,
  &_swigt__p_ctlio__geometric_object_list,
  &_swigt__p_ctlio__material_type,
  &_swigt__p_ctlio__material_type_list,
  &_swigt__p_ctlio__pml_list,
  &_swigt__p_ctlio__symmetry_list,
  &_swigt__p_double,
  &_swigt__p_f_double_int_p_void__meep__vec,
  &_swigt__p_f_double_p_void__double,
  &_swigt__p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void,
  &_swigt__p_f_p_q_const__char__void,
  &_swigt__p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double,
  &_swigt__p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t,
  &_swigt__p_f_r_q_const__meep__vec__double,
  &_swigt__p_float,
  &_swigt__p_int,
  &_swigt__p_kpoint_list,
  &_swigt__p_long_double,
  &_swigt__p_meep__binary_partition,
  &_swigt__p_meep__boundary_region,
  &_swigt__p_meep__chunkloop_field_components,
  &_swigt__p_meep__component,
  &_swigt__p_meep__continuous_src_time,
  &_swigt__p_meep__custom_src_time,
  &_swigt__p_meep__dft_chunk,
  &_swigt__p_meep__dft_energy,
  &_swigt__p_meep__dft_fields,
  &_swigt__p_meep__dft_flux,
  &_swigt__p_meep__dft_force,
  &_swigt__p_meep__dft_ldos,
  &_swigt__p_meep__dft_near2far,
  &_swigt__p_meep__diffractedplanewave,
  &_swigt__p_meep__direction,
  &_swigt__p_meep__fields,
  &_swigt__p_meep__fields_chunk,
  &_swigt__p_meep__flux_vol,
  &_swigt__p_meep__gaussian_src_time,
  &_swigt__p_meep__gaussianbeam,
  &_swigt__p_meep__grid_volume,
  &_swigt__p_meep__gyrotropic_susceptibility,
  &_swigt__p_meep__gyrotropy_model,
  &_swigt__p_meep__h5file,
  &_swigt__p_meep__h5file__extending_s,
  &_swigt__p_meep__initialize,
  &_swigt__p_meep__ivec,
  &_swigt__p_meep__lorentzian_susceptibility,
  &_swigt__p_meep__material_function,
  &_swigt__p_meep__monitor_point,
  &_swigt__p_meep__multilevel_susceptibility,
  &_swigt__p_meep__noisy_lorentzian_susceptibility,
  &_swigt__p_meep__polarization_state_s,
  &_swigt__p_meep__signed_direction,
  &_swigt__p_meep__simple_material_function,
  &_swigt__p_meep__sourcedata,
  &_swigt__p_meep__split_plane,
  &_swigt__p_meep__src_time,
  &_swigt__p_meep__structure,
  &_swigt__p_meep__structure_chunk,
  &_swigt__p_meep__susceptibility,
  &_swigt__p_meep__symmetry,
  &_swigt__p_meep__timing_scope,
  &_swigt__p_meep__vec,
  &_swigt__p_meep__volume,
  &_swigt__p_meep__volume_list,
  &_swigt__p_p_double,
  &_swigt__p_p_meep__continuous_src_time,
  &_swigt__p_p_meep__custom_src_time,
  &_swigt__p_p_meep__dft_chunk,
  &_swigt__p_p_meep__fields_chunk,
  &_swigt__p_p_meep__gaussian_src_time,
  &_swigt__p_p_meep__gyrotropic_susceptibility,
  &_swigt__p_p_meep__lorentzian_susceptibility,
  &_swigt__p_p_meep__multilevel_susceptibility,
  &_swigt__p_p_meep__noisy_lorentzian_susceptibility,
  &_swigt__p_p_meep__src_time,
  &_swigt__p_p_meep__structure_chunk,
  &_swigt__p_p_meep__susceptibility,
  &_swigt__p_p_p_char,
  &_swigt__p_p_std__complexT_double_t,
  &_swigt__p_p_void,
  &_swigt__p_ptrdiff_t,
  &_swigt__p_size_t,
  &_swigt__p_std__complexT_double_t,
  &_swigt__p_std__complexT_float_t,
  &_swigt__p_std__complexT_long_double_t,
  &_swigt__p_std__pairT_int_int_t,
  &_swigt__p_std__unique_ptrT_meep__binary_partition_t,
  &_swigt__p_std__unordered_mapT_meep__time_sink_double_std__hashT_int_t_t,
  &_swigt__p_std__unordered_mapT_meep__time_sink_std__vectorT_double_t_std__hashT_int_t_t,
  &_swigt__p_std__vectorT_double_t,
  &_swigt__p_std__vectorT_int_t,
  &_swigt__p_std__vectorT_meep__component_t,
  &_swigt__p_std__vectorT_meep__grid_volume_t,
  &_swigt__p_std__vectorT_meep__sourcedata_t,
  &_swigt__p_std__vectorT_ptrdiff_t_t,
  &_swigt__p_std__vectorT_size_t_t,
  &_swigt__p_std__vectorT_std__complexT_double_t_t,
  &_swigt__p_unsigned_long,
  &_swigt__p_vector3,
  &_swigt__p_void,
};

static swig_cast_info _swigc__p_FILE[] = {  {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_2__p_double[] = {  {&_swigt__p_a_2__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_5__bool[] = {  {&_swigt__p_a_5__bool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_5__meep__boundary_condition[] = {  {&_swigt__p_a_5__meep__boundary_condition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_5__p_double[] = {  {&_swigt__p_a_5__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_9__std__complexT_double_t[] = {  {&_swigt__p_a_9__std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_access_mode[] = {  {&_swigt__p_access_mode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bool[] = {  {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_boundary_region_kind[] = {  {&_swigt__p_boundary_region_kind, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ctlio__cnumber_list[] = {  {&_swigt__p_ctlio__cnumber_list, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ctlio__geometric_object_list[] = {  {&_swigt__p_ctlio__geometric_object_list, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ctlio__material_type[] = {  {&_swigt__p_ctlio__material_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ctlio__material_type_list[] = {  {&_swigt__p_ctlio__material_type_list, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ctlio__pml_list[] = {  {&_swigt__p_ctlio__pml_list, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ctlio__symmetry_list[] = {  {&_swigt__p_ctlio__symmetry_list, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_double_int_p_void__meep__vec[] = {  {&_swigt__p_f_double_int_p_void__meep__vec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_double_p_void__double[] = {  {&_swigt__p_f_double_p_void__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void[] = {  {&_swigt__p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__char__void[] = {  {&_swigt__p_f_p_q_const__char__void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double[] = {  {&_swigt__p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t[] = {  {&_swigt__p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_f_r_q_const__meep__vec__double[] = {  {&_swigt__p_f_r_q_const__meep__vec__double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_kpoint_list[] = {  {&_swigt__p_kpoint_list, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_long_double[] = {  {&_swigt__p_long_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__binary_partition[] = {  {&_swigt__p_meep__binary_partition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__boundary_region[] = {  {&_swigt__p_meep__boundary_region, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__chunkloop_field_components[] = {  {&_swigt__p_meep__chunkloop_field_components, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__component[] = {  {&_swigt__p_meep__component, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__continuous_src_time[] = {  {&_swigt__p_meep__continuous_src_time, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__custom_src_time[] = {  {&_swigt__p_meep__custom_src_time, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__dft_chunk[] = {  {&_swigt__p_meep__dft_chunk, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__dft_energy[] = {  {&_swigt__p_meep__dft_energy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__dft_fields[] = {  {&_swigt__p_meep__dft_fields, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__dft_flux[] = {  {&_swigt__p_meep__dft_flux, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__dft_force[] = {  {&_swigt__p_meep__dft_force, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__dft_ldos[] = {  {&_swigt__p_meep__dft_ldos, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__dft_near2far[] = {  {&_swigt__p_meep__dft_near2far, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__diffractedplanewave[] = {  {&_swigt__p_meep__diffractedplanewave, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__direction[] = {  {&_swigt__p_meep__direction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__fields[] = {  {&_swigt__p_meep__fields, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__fields_chunk[] = {  {&_swigt__p_meep__fields_chunk, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__flux_vol[] = {  {&_swigt__p_meep__flux_vol, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__gaussian_src_time[] = {  {&_swigt__p_meep__gaussian_src_time, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__gaussianbeam[] = {  {&_swigt__p_meep__gaussianbeam, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__grid_volume[] = {  {&_swigt__p_meep__grid_volume, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__gyrotropic_susceptibility[] = {  {&_swigt__p_meep__gyrotropic_susceptibility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__gyrotropy_model[] = {  {&_swigt__p_meep__gyrotropy_model, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__h5file[] = {  {&_swigt__p_meep__h5file, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__h5file__extending_s[] = {  {&_swigt__p_meep__h5file__extending_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__initialize[] = {  {&_swigt__p_meep__initialize, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__ivec[] = {  {&_swigt__p_meep__ivec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__lorentzian_susceptibility[] = {  {&_swigt__p_meep__lorentzian_susceptibility, 0, 0, 0},  {&_swigt__p_meep__noisy_lorentzian_susceptibility, _p_meep__noisy_lorentzian_susceptibilityTo_p_meep__lorentzian_susceptibility, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__material_function[] = {  {&_swigt__p_meep__material_function, 0, 0, 0},  {&_swigt__p_meep__simple_material_function, _p_meep__simple_material_functionTo_p_meep__material_function, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__monitor_point[] = {  {&_swigt__p_meep__monitor_point, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__multilevel_susceptibility[] = {  {&_swigt__p_meep__multilevel_susceptibility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__noisy_lorentzian_susceptibility[] = {  {&_swigt__p_meep__noisy_lorentzian_susceptibility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__polarization_state_s[] = {  {&_swigt__p_meep__polarization_state_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__signed_direction[] = {  {&_swigt__p_meep__signed_direction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__simple_material_function[] = {  {&_swigt__p_meep__simple_material_function, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__sourcedata[] = {  {&_swigt__p_meep__sourcedata, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__split_plane[] = {  {&_swigt__p_meep__split_plane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__src_time[] = {  {&_swigt__p_meep__src_time, 0, 0, 0},  {&_swigt__p_meep__gaussian_src_time, _p_meep__gaussian_src_timeTo_p_meep__src_time, 0, 0},  {&_swigt__p_meep__continuous_src_time, _p_meep__continuous_src_timeTo_p_meep__src_time, 0, 0},  {&_swigt__p_meep__custom_src_time, _p_meep__custom_src_timeTo_p_meep__src_time, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__structure[] = {  {&_swigt__p_meep__structure, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__structure_chunk[] = {  {&_swigt__p_meep__structure_chunk, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__susceptibility[] = {  {&_swigt__p_meep__susceptibility, 0, 0, 0},  {&_swigt__p_meep__lorentzian_susceptibility, _p_meep__lorentzian_susceptibilityTo_p_meep__susceptibility, 0, 0},  {&_swigt__p_meep__noisy_lorentzian_susceptibility, _p_meep__noisy_lorentzian_susceptibilityTo_p_meep__susceptibility, 0, 0},  {&_swigt__p_meep__gyrotropic_susceptibility, _p_meep__gyrotropic_susceptibilityTo_p_meep__susceptibility, 0, 0},  {&_swigt__p_meep__multilevel_susceptibility, _p_meep__multilevel_susceptibilityTo_p_meep__susceptibility, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__symmetry[] = {  {&_swigt__p_meep__symmetry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__timing_scope[] = {  {&_swigt__p_meep__timing_scope, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__vec[] = {  {&_swigt__p_meep__vec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__volume[] = {  {&_swigt__p_meep__volume, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_meep__volume_list[] = {  {&_swigt__p_meep__volume_list, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_double[] = {  {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_meep__dft_chunk[] = {  {&_swigt__p_p_meep__dft_chunk, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_meep__fields_chunk[] = {  {&_swigt__p_p_meep__fields_chunk, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_meep__gaussian_src_time[] = {{&_swigt__p_p_meep__gaussian_src_time, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_meep__continuous_src_time[] = {{&_swigt__p_p_meep__continuous_src_time, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_meep__custom_src_time[] = {{&_swigt__p_p_meep__custom_src_time, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_meep__src_time[] = {  {&_swigt__p_p_meep__src_time, 0, 0, 0},  {&_swigt__p_p_meep__gaussian_src_time, _p_p_meep__gaussian_src_timeTo_p_p_meep__src_time, 0, 0},  {&_swigt__p_p_meep__continuous_src_time, _p_p_meep__continuous_src_timeTo_p_p_meep__src_time, 0, 0},  {&_swigt__p_p_meep__custom_src_time, _p_p_meep__custom_src_timeTo_p_p_meep__src_time, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_meep__structure_chunk[] = {  {&_swigt__p_p_meep__structure_chunk, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_meep__lorentzian_susceptibility[] = {{&_swigt__p_p_meep__lorentzian_susceptibility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_meep__noisy_lorentzian_susceptibility[] = {{&_swigt__p_p_meep__noisy_lorentzian_susceptibility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_meep__gyrotropic_susceptibility[] = {{&_swigt__p_p_meep__gyrotropic_susceptibility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_meep__multilevel_susceptibility[] = {{&_swigt__p_p_meep__multilevel_susceptibility, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_meep__susceptibility[] = {  {&_swigt__p_p_meep__susceptibility, 0, 0, 0},  {&_swigt__p_p_meep__lorentzian_susceptibility, _p_p_meep__lorentzian_susceptibilityTo_p_p_meep__susceptibility, 0, 0},  {&_swigt__p_p_meep__noisy_lorentzian_susceptibility, _p_p_meep__noisy_lorentzian_susceptibilityTo_p_p_meep__susceptibility, 0, 0},  {&_swigt__p_p_meep__gyrotropic_susceptibility, _p_p_meep__gyrotropic_susceptibilityTo_p_p_meep__susceptibility, 0, 0},  {&_swigt__p_p_meep__multilevel_susceptibility, _p_p_meep__multilevel_susceptibilityTo_p_p_meep__susceptibility, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_p_char[] = {  {&_swigt__p_p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_std__complexT_double_t[] = {  {&_swigt__p_p_std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ptrdiff_t[] = {  {&_swigt__p_ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_t[] = {  {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__complexT_double_t[] = {  {&_swigt__p_std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__complexT_float_t[] = {  {&_swigt__p_std__complexT_float_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__complexT_long_double_t[] = {  {&_swigt__p_std__complexT_long_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_int_int_t[] = {  {&_swigt__p_std__pairT_int_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unique_ptrT_meep__binary_partition_t[] = {  {&_swigt__p_std__unique_ptrT_meep__binary_partition_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unordered_mapT_meep__time_sink_double_std__hashT_int_t_t[] = {  {&_swigt__p_std__unordered_mapT_meep__time_sink_double_std__hashT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__unordered_mapT_meep__time_sink_std__vectorT_double_t_std__hashT_int_t_t[] = {  {&_swigt__p_std__unordered_mapT_meep__time_sink_std__vectorT_double_t_std__hashT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_double_t[] = {  {&_swigt__p_std__vectorT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_int_t[] = {  {&_swigt__p_std__vectorT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_meep__component_t[] = {  {&_swigt__p_std__vectorT_meep__component_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_meep__grid_volume_t[] = {  {&_swigt__p_std__vectorT_meep__grid_volume_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_meep__sourcedata_t[] = {  {&_swigt__p_std__vectorT_meep__sourcedata_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_ptrdiff_t_t[] = {  {&_swigt__p_std__vectorT_ptrdiff_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_size_t_t[] = {  {&_swigt__p_std__vectorT_size_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__complexT_double_t_t[] = {  {&_swigt__p_std__vectorT_std__complexT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vector3[] = {  {&_swigt__p_vector3, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_FILE,
  _swigc__p_a_2__p_double,
  _swigc__p_a_5__bool,
  _swigc__p_a_5__meep__boundary_condition,
  _swigc__p_a_5__p_double,
  _swigc__p_a_9__std__complexT_double_t,
  _swigc__p_access_mode,
  _swigc__p_bool,
  _swigc__p_boundary_region_kind,
  _swigc__p_ctlio__cnumber_list,
  _swigc__p_ctlio__geometric_object_list,
  _swigc__p_ctlio__material_type,
  _swigc__p_ctlio__material_type_list,
  _swigc__p_ctlio__pml_list,
  _swigc__p_ctlio__symmetry_list,
  _swigc__p_double,
  _swigc__p_f_double_int_p_void__meep__vec,
  _swigc__p_f_double_p_void__double,
  _swigc__p_f_p_meep__fields_chunk_int_enum_meep__component_meep__ivec_meep__ivec_meep__vec_meep__vec_meep__vec_meep__vec_double_double_meep__ivec_std__complex__double___r_q_const__meep__symmetry_int_p_void__void,
  _swigc__p_f_p_q_const__char__void,
  _swigc__p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__double,
  _swigc__p_f_p_q_const__std__complex__double___r_q_const__meep__vec_p_void__std__complexT_double_t,
  _swigc__p_f_r_q_const__meep__vec__double,
  _swigc__p_float,
  _swigc__p_int,
  _swigc__p_kpoint_list,
  _swigc__p_long_double,
  _swigc__p_meep__binary_partition,
  _swigc__p_meep__boundary_region,
  _swigc__p_meep__chunkloop_field_components,
  _swigc__p_meep__component,
  _swigc__p_meep__continuous_src_time,
  _swigc__p_meep__custom_src_time,
  _swigc__p_meep__dft_chunk,
  _swigc__p_meep__dft_energy,
  _swigc__p_meep__dft_fields,
  _swigc__p_meep__dft_flux,
  _swigc__p_meep__dft_force,
  _swigc__p_meep__dft_ldos,
  _swigc__p_meep__dft_near2far,
  _swigc__p_meep__diffractedplanewave,
  _swigc__p_meep__direction,
  _swigc__p_meep__fields,
  _swigc__p_meep__fields_chunk,
  _swigc__p_meep__flux_vol,
  _swigc__p_meep__gaussian_src_time,
  _swigc__p_meep__gaussianbeam,
  _swigc__p_meep__grid_volume,
  _swigc__p_meep__gyrotropic_susceptibility,
  _swigc__p_meep__gyrotropy_model,
  _swigc__p_meep__h5file,
  _swigc__p_meep__h5file__extending_s,
  _swigc__p_meep__initialize,
  _swigc__p_meep__ivec,
  _swigc__p_meep__lorentzian_susceptibility,
  _swigc__p_meep__material_function,
  _swigc__p_meep__monitor_point,
  _swigc__p_meep__multilevel_susceptibility,
  _swigc__p_meep__noisy_lorentzian_susceptibility,
  _swigc__p_meep__polarization_state_s,
  _swigc__p_meep__signed_direction,
  _swigc__p_meep__simple_material_function,
  _swigc__p_meep__sourcedata,
  _swigc__p_meep__split_plane,
  _swigc__p_meep__src_time,
  _swigc__p_meep__structure,
  _swigc__p_meep__structure_chunk,
  _swigc__p_meep__susceptibility,
  _swigc__p_meep__symmetry,
  _swigc__p_meep__timing_scope,
  _swigc__p_meep__vec,
  _swigc__p_meep__volume,
  _swigc__p_meep__volume_list,
  _swigc__p_p_double,
  _swigc__p_p_meep__continuous_src_time,
  _swigc__p_p_meep__custom_src_time,
  _swigc__p_p_meep__dft_chunk,
  _swigc__p_p_meep__fields_chunk,
  _swigc__p_p_meep__gaussian_src_time,
  _swigc__p_p_meep__gyrotropic_susceptibility,
  _swigc__p_p_meep__lorentzian_susceptibility,
  _swigc__p_p_meep__multilevel_susceptibility,
  _swigc__p_p_meep__noisy_lorentzian_susceptibility,
  _swigc__p_p_meep__src_time,
  _swigc__p_p_meep__structure_chunk,
  _swigc__p_p_meep__susceptibility,
  _swigc__p_p_p_char,
  _swigc__p_p_std__complexT_double_t,
  _swigc__p_p_void,
  _swigc__p_ptrdiff_t,
  _swigc__p_size_t,
  _swigc__p_std__complexT_double_t,
  _swigc__p_std__complexT_float_t,
  _swigc__p_std__complexT_long_double_t,
  _swigc__p_std__pairT_int_int_t,
  _swigc__p_std__unique_ptrT_meep__binary_partition_t,
  _swigc__p_std__unordered_mapT_meep__time_sink_double_std__hashT_int_t_t,
  _swigc__p_std__unordered_mapT_meep__time_sink_std__vectorT_double_t_std__hashT_int_t_t,
  _swigc__p_std__vectorT_double_t,
  _swigc__p_std__vectorT_int_t,
  _swigc__p_std__vectorT_meep__component_t,
  _swigc__p_std__vectorT_meep__grid_volume_t,
  _swigc__p_std__vectorT_meep__sourcedata_t,
  _swigc__p_std__vectorT_ptrdiff_t_t,
  _swigc__p_std__vectorT_size_t_t,
  _swigc__p_std__vectorT_std__complexT_double_t_t,
  _swigc__p_unsigned_long,
  _swigc__p_vector3,
  _swigc__p_void,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
        if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
          cast->type = ret;
          ret = 0;
        } else {
          /* Check for casting already in the list */
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
          if (!ocast) ret = 0;
        }
      }
      
      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{
  /* c-mode */
#endif
}
#endif


SWIG_GUILE_INIT_STATIC void
SWIG_init(void)
{
  SWIG_InitializeModule(0);
  SWIG_PropagateClientData();
  
  scm_c_define_gsubr("NUM-FIELD-COMPONENTS", 0, 0, 0, (swig_guile_proc) _wrap_NUM_FIELD_COMPONENTS);
  scm_c_define_gsubr("NUM-FIELD-TYPES", 0, 0, 0, (swig_guile_proc) _wrap_NUM_FIELD_TYPES);
  scm_c_define_gsubr("meep-component-Ex", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Ex);
  scm_c_define_gsubr("meep-component-Ey", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Ey);
  scm_c_define_gsubr("meep-component-Er", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Er);
  scm_c_define_gsubr("meep-component-Ep", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Ep);
  scm_c_define_gsubr("meep-component-Ez", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Ez);
  scm_c_define_gsubr("meep-component-Hx", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Hx);
  scm_c_define_gsubr("meep-component-Hy", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Hy);
  scm_c_define_gsubr("meep-component-Hr", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Hr);
  scm_c_define_gsubr("meep-component-Hp", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Hp);
  scm_c_define_gsubr("meep-component-Hz", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Hz);
  scm_c_define_gsubr("meep-component-Dx", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Dx);
  scm_c_define_gsubr("meep-component-Dy", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Dy);
  scm_c_define_gsubr("meep-component-Dr", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Dr);
  scm_c_define_gsubr("meep-component-Dp", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Dp);
  scm_c_define_gsubr("meep-component-Dz", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Dz);
  scm_c_define_gsubr("meep-component-Bx", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Bx);
  scm_c_define_gsubr("meep-component-By", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_By);
  scm_c_define_gsubr("meep-component-Br", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Br);
  scm_c_define_gsubr("meep-component-Bp", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Bp);
  scm_c_define_gsubr("meep-component-Bz", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Bz);
  scm_c_define_gsubr("meep-component-Dielectric", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Dielectric);
  scm_c_define_gsubr("meep-component-Permeability", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_Permeability);
  scm_c_define_gsubr("meep-component-NO-COMPONENT", 0, 0, 0, (swig_guile_proc) _wrap_meep_component_NO_COMPONENT);
  scm_c_define_gsubr("Centered", 0, 0, 0, (swig_guile_proc) _wrap_Centered);
  scm_c_define_gsubr("meep-derived-component-Sx", 0, 0, 0, (swig_guile_proc) _wrap_meep_derived_component_Sx);
  scm_c_define_gsubr("meep-derived-component-Sy", 0, 0, 0, (swig_guile_proc) _wrap_meep_derived_component_Sy);
  scm_c_define_gsubr("meep-derived-component-Sr", 0, 0, 0, (swig_guile_proc) _wrap_meep_derived_component_Sr);
  scm_c_define_gsubr("meep-derived-component-Sp", 0, 0, 0, (swig_guile_proc) _wrap_meep_derived_component_Sp);
  scm_c_define_gsubr("meep-derived-component-Sz", 0, 0, 0, (swig_guile_proc) _wrap_meep_derived_component_Sz);
  scm_c_define_gsubr("meep-derived-component-EnergyDensity", 0, 0, 0, (swig_guile_proc) _wrap_meep_derived_component_EnergyDensity);
  scm_c_define_gsubr("meep-derived-component-D-EnergyDensity", 0, 0, 0, (swig_guile_proc) _wrap_meep_derived_component_D_EnergyDensity);
  scm_c_define_gsubr("meep-derived-component-H-EnergyDensity", 0, 0, 0, (swig_guile_proc) _wrap_meep_derived_component_H_EnergyDensity);
  scm_c_define_gsubr("meep-ndim-D1", 0, 0, 0, (swig_guile_proc) _wrap_meep_ndim_D1);
  scm_c_define_gsubr("meep-ndim-D2", 0, 0, 0, (swig_guile_proc) _wrap_meep_ndim_D2);
  scm_c_define_gsubr("meep-ndim-D3", 0, 0, 0, (swig_guile_proc) _wrap_meep_ndim_D3);
  scm_c_define_gsubr("meep-ndim-Dcyl", 0, 0, 0, (swig_guile_proc) _wrap_meep_ndim_Dcyl);
  scm_c_define_gsubr("meep-field-type-E-stuff", 0, 0, 0, (swig_guile_proc) _wrap_meep_field_type_E_stuff);
  scm_c_define_gsubr("meep-field-type-H-stuff", 0, 0, 0, (swig_guile_proc) _wrap_meep_field_type_H_stuff);
  scm_c_define_gsubr("meep-field-type-D-stuff", 0, 0, 0, (swig_guile_proc) _wrap_meep_field_type_D_stuff);
  scm_c_define_gsubr("meep-field-type-B-stuff", 0, 0, 0, (swig_guile_proc) _wrap_meep_field_type_B_stuff);
  scm_c_define_gsubr("meep-field-type-PE-stuff", 0, 0, 0, (swig_guile_proc) _wrap_meep_field_type_PE_stuff);
  scm_c_define_gsubr("meep-field-type-PH-stuff", 0, 0, 0, (swig_guile_proc) _wrap_meep_field_type_PH_stuff);
  scm_c_define_gsubr("meep-field-type-WE-stuff", 0, 0, 0, (swig_guile_proc) _wrap_meep_field_type_WE_stuff);
  scm_c_define_gsubr("meep-field-type-WH-stuff", 0, 0, 0, (swig_guile_proc) _wrap_meep_field_type_WH_stuff);
  scm_c_define_gsubr("meep-boundary-side-High", 0, 0, 0, (swig_guile_proc) _wrap_meep_boundary_side_High);
  scm_c_define_gsubr("meep-boundary-side-Low", 0, 0, 0, (swig_guile_proc) _wrap_meep_boundary_side_Low);
  scm_c_define_gsubr("meep-direction-X", 0, 0, 0, (swig_guile_proc) _wrap_meep_direction_X);
  scm_c_define_gsubr("meep-direction-Y", 0, 0, 0, (swig_guile_proc) _wrap_meep_direction_Y);
  scm_c_define_gsubr("meep-direction-Z", 0, 0, 0, (swig_guile_proc) _wrap_meep_direction_Z);
  scm_c_define_gsubr("meep-direction-R", 0, 0, 0, (swig_guile_proc) _wrap_meep_direction_R);
  scm_c_define_gsubr("meep-direction-P", 0, 0, 0, (swig_guile_proc) _wrap_meep_direction_P);
  scm_c_define_gsubr("meep-direction-NO-DIRECTION", 0, 0, 0, (swig_guile_proc) _wrap_meep_direction_NO_DIRECTION);
  SWIG_TypeClientData(SWIGTYPE_p_meep__signed_direction, (void *) &_swig_guile_clientdatasigned_direction);
  scm_c_define_gsubr("new-signed-direction", 0, 0, 1, (swig_guile_proc) _wrap_new_signed_direction);
  scm_c_define_gsubr("signed-direction-d-set", 2, 0, 0, (swig_guile_proc) _wrap_signed_direction_d_set);
  scm_c_define_gsubr("signed-direction-d-get", 1, 0, 0, (swig_guile_proc) _wrap_signed_direction_d_get);
  scm_c_define_gsubr("signed-direction-flipped-set", 2, 0, 0, (swig_guile_proc) _wrap_signed_direction_flipped_set);
  scm_c_define_gsubr("signed-direction-flipped-get", 1, 0, 0, (swig_guile_proc) _wrap_signed_direction_flipped_get);
  scm_c_define_gsubr("signed-direction-phase-set", 2, 0, 0, (swig_guile_proc) _wrap_signed_direction_phase_set);
  scm_c_define_gsubr("signed-direction-phase-get", 1, 0, 0, (swig_guile_proc) _wrap_signed_direction_phase_get);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__signed_direction->clientdata))->destroy = (guile_destructor) _wrap_delete_signed_direction;
  scm_c_define_gsubr("delete-signed-direction", 1, 0, 0, (swig_guile_proc) _wrap_delete_signed_direction);
  scm_c_define_gsubr("meep-number-of-directions", 1, 0, 0, (swig_guile_proc) _wrap_meep_number_of_directions);
  scm_c_define_gsubr("meep-start-at-direction", 1, 0, 0, (swig_guile_proc) _wrap_meep_start_at_direction);
  scm_c_define_gsubr("meep-stop-at-direction", 1, 0, 0, (swig_guile_proc) _wrap_meep_stop_at_direction);
  scm_c_define_gsubr("meep-first-field-component", 1, 0, 0, (swig_guile_proc) _wrap_meep_first_field_component);
  scm_c_define_gsubr("meep-flip", 1, 0, 0, (swig_guile_proc) _wrap_meep_flip);
  scm_c_define_gsubr("meep-has-direction", 2, 0, 0, (swig_guile_proc) _wrap_meep_has_direction);
  scm_c_define_gsubr("meep-has-field-direction", 2, 0, 0, (swig_guile_proc) _wrap_meep_has_field_direction);
  scm_c_define_gsubr("meep-is-tm", 1, 0, 0, (swig_guile_proc) _wrap_meep_is_tm);
  scm_c_define_gsubr("meep-abort", 1, 0, 0, (swig_guile_proc) _wrap_meep_abort);
  scm_c_define_gsubr("meep-is-electric", 1, 0, 0, (swig_guile_proc) _wrap_meep_is_electric);
  scm_c_define_gsubr("meep-is-magnetic", 1, 0, 0, (swig_guile_proc) _wrap_meep_is_magnetic);
  scm_c_define_gsubr("meep-is-D", 1, 0, 0, (swig_guile_proc) _wrap_meep_is_D);
  scm_c_define_gsubr("meep-is-B", 1, 0, 0, (swig_guile_proc) _wrap_meep_is_B);
  scm_c_define_gsubr("meep-is-E-or-D", 1, 0, 0, (swig_guile_proc) _wrap_meep_is_E_or_D);
  scm_c_define_gsubr("meep-is-H-or-B", 1, 0, 0, (swig_guile_proc) _wrap_meep_is_H_or_B);
  scm_c_define_gsubr("meep-is-derived", 1, 0, 0, (swig_guile_proc) _wrap_meep_is_derived);
  scm_c_define_gsubr("meep-is-poynting", 1, 0, 0, (swig_guile_proc) _wrap_meep_is_poynting);
  scm_c_define_gsubr("meep-is-energydensity", 1, 0, 0, (swig_guile_proc) _wrap_meep_is_energydensity);
  scm_c_define_gsubr("meep-type", 1, 0, 0, (swig_guile_proc) _wrap_meep_type);
  scm_c_define_gsubr("meep-component-name", 0, 0, 1, (swig_guile_proc) _wrap_meep_component_name);
  scm_c_define_gsubr("meep-direction-name", 1, 0, 0, (swig_guile_proc) _wrap_meep_direction_name);
  scm_c_define_gsubr("meep-dimension-name", 1, 0, 0, (swig_guile_proc) _wrap_meep_dimension_name);
  scm_c_define_gsubr("meep-component-index", 1, 0, 0, (swig_guile_proc) _wrap_meep_component_index);
  scm_c_define_gsubr("meep-component-direction", 0, 0, 1, (swig_guile_proc) _wrap_meep_component_direction);
  scm_c_define_gsubr("meep-direction-component", 0, 0, 1, (swig_guile_proc) _wrap_meep_direction_component);
  scm_c_define_gsubr("meep-field-type-component", 2, 0, 0, (swig_guile_proc) _wrap_meep_field_type_component);
  scm_c_define_gsubr("meep-coordinate-mismatch", 0, 0, 1, (swig_guile_proc) _wrap_meep_coordinate_mismatch);
  scm_c_define_gsubr("meep-cycle-direction", 3, 0, 0, (swig_guile_proc) _wrap_meep_cycle_direction);
  scm_c_define_gsubr("meep-cycle-component", 3, 0, 0, (swig_guile_proc) _wrap_meep_cycle_component);
  scm_c_define_gsubr("meep-veccyl", 2, 0, 0, (swig_guile_proc) _wrap_meep_veccyl);
  scm_c_define_gsubr("meep-zero-vec", 1, 0, 0, (swig_guile_proc) _wrap_meep_zero_vec);
  SWIG_TypeClientData(SWIGTYPE_p_meep__vec, (void *) &_swig_guile_clientdatameep_vec);
  scm_c_define_gsubr("new-meep-vec", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_vec);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__vec->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_vec;
  scm_c_define_gsubr("delete-meep-vec", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_vec);
  scm_c_define_gsubr("meep-vec-round-float", 1, 0, 0, (swig_guile_proc) _wrap_meep_vec_round_float);
  scm_c_define_gsubr("meep-vec-dim-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_vec_dim_set);
  scm_c_define_gsubr("meep-vec-dim-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_vec_dim_get);
  scm_c_define_gsubr("meep-vec-r", 1, 0, 0, (swig_guile_proc) _wrap_meep_vec_r);
  scm_c_define_gsubr("meep-vec-x", 1, 0, 0, (swig_guile_proc) _wrap_meep_vec_x);
  scm_c_define_gsubr("meep-vec-y", 1, 0, 0, (swig_guile_proc) _wrap_meep_vec_y);
  scm_c_define_gsubr("meep-vec-z", 1, 0, 0, (swig_guile_proc) _wrap_meep_vec_z);
  scm_c_define_gsubr("meep-vec-in-direction", 2, 0, 0, (swig_guile_proc) _wrap_meep_vec_in_direction);
  scm_c_define_gsubr("meep-vec-set-direction", 3, 0, 0, (swig_guile_proc) _wrap_meep_vec_set_direction);
  scm_c_define_gsubr("meep-vec-str", 0, 0, 1, (swig_guile_proc) _wrap_meep_vec_str);
  scm_c_define_gsubr("meep-vec-project-to-boundary", 3, 0, 0, (swig_guile_proc) _wrap_meep_vec_project_to_boundary);
  scm_c_define_gsubr("meep-one-vec", 1, 0, 0, (swig_guile_proc) _wrap_meep_one_vec);
  scm_c_define_gsubr("meep-abs", 1, 0, 0, (swig_guile_proc) _wrap_meep_abs);
  scm_c_define_gsubr("meep-unit-vec", 2, 0, 0, (swig_guile_proc) _wrap_meep_unit_vec);
  scm_c_define_gsubr("meep-clean-vec", 0, 0, 1, (swig_guile_proc) _wrap_meep_clean_vec);
  scm_c_define_gsubr("meep-iveccyl", 2, 0, 0, (swig_guile_proc) _wrap_meep_iveccyl);
  scm_c_define_gsubr("meep-zero-ivec", 1, 0, 0, (swig_guile_proc) _wrap_meep_zero_ivec);
  scm_c_define_gsubr("meep-one-ivec", 1, 0, 0, (swig_guile_proc) _wrap_meep_one_ivec);
  SWIG_TypeClientData(SWIGTYPE_p_meep__ivec, (void *) &_swig_guile_clientdatameep_ivec);
  scm_c_define_gsubr("new-meep-ivec", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_ivec);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__ivec->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_ivec;
  scm_c_define_gsubr("delete-meep-ivec", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_ivec);
  scm_c_define_gsubr("meep-ivec-yucky-val", 2, 0, 0, (swig_guile_proc) _wrap_meep_ivec_yucky_val);
  scm_c_define_gsubr("meep-ivec-dim-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_ivec_dim_set);
  scm_c_define_gsubr("meep-ivec-dim-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_ivec_dim_get);
  scm_c_define_gsubr("meep-ivec-r", 1, 0, 0, (swig_guile_proc) _wrap_meep_ivec_r);
  scm_c_define_gsubr("meep-ivec-x", 1, 0, 0, (swig_guile_proc) _wrap_meep_ivec_x);
  scm_c_define_gsubr("meep-ivec-y", 1, 0, 0, (swig_guile_proc) _wrap_meep_ivec_y);
  scm_c_define_gsubr("meep-ivec-z", 1, 0, 0, (swig_guile_proc) _wrap_meep_ivec_z);
  scm_c_define_gsubr("meep-ivec-in-direction", 2, 0, 0, (swig_guile_proc) _wrap_meep_ivec_in_direction);
  scm_c_define_gsubr("meep-ivec-set-direction", 3, 0, 0, (swig_guile_proc) _wrap_meep_ivec_set_direction);
  scm_c_define_gsubr("meep-ivec-str", 0, 0, 1, (swig_guile_proc) _wrap_meep_ivec_str);
  scm_c_define_gsubr("meep-ivec-round-down-to-even", 1, 0, 0, (swig_guile_proc) _wrap_meep_ivec_round_down_to_even);
  scm_c_define_gsubr("meep-unit-ivec", 2, 0, 0, (swig_guile_proc) _wrap_meep_unit_ivec);
  scm_c_define_gsubr("meep-max", 0, 0, 1, (swig_guile_proc) _wrap_meep_max);
  scm_c_define_gsubr("meep-min", 0, 0, 1, (swig_guile_proc) _wrap_meep_min);
  SWIG_TypeClientData(SWIGTYPE_p_meep__volume, (void *) &_swig_guile_clientdatameep_volume);
  scm_c_define_gsubr("meep-volume-dim-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_volume_dim_set);
  scm_c_define_gsubr("meep-volume-dim-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_volume_dim_get);
  scm_c_define_gsubr("new-meep-volume", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_volume);
  scm_c_define_gsubr("meep-volume-set-direction-min", 3, 0, 0, (swig_guile_proc) _wrap_meep_volume_set_direction_min);
  scm_c_define_gsubr("meep-volume-set-direction-max", 3, 0, 0, (swig_guile_proc) _wrap_meep_volume_set_direction_max);
  scm_c_define_gsubr("meep-volume-in-direction-min", 2, 0, 0, (swig_guile_proc) _wrap_meep_volume_in_direction_min);
  scm_c_define_gsubr("meep-volume-in-direction-max", 2, 0, 0, (swig_guile_proc) _wrap_meep_volume_in_direction_max);
  scm_c_define_gsubr("meep-volume-in-direction", 2, 0, 0, (swig_guile_proc) _wrap_meep_volume_in_direction);
  scm_c_define_gsubr("meep-volume-computational-volume", 1, 0, 0, (swig_guile_proc) _wrap_meep_volume_computational_volume);
  scm_c_define_gsubr("meep-volume-integral-volume", 1, 0, 0, (swig_guile_proc) _wrap_meep_volume_integral_volume);
  scm_c_define_gsubr("meep-volume-full-volume", 1, 0, 0, (swig_guile_proc) _wrap_meep_volume_full_volume);
  scm_c_define_gsubr("meep-volume-center", 1, 0, 0, (swig_guile_proc) _wrap_meep_volume_center);
  scm_c_define_gsubr("meep-volume-diameter", 1, 0, 0, (swig_guile_proc) _wrap_meep_volume_diameter);
  scm_c_define_gsubr("meep-volume-contains", 0, 0, 1, (swig_guile_proc) _wrap_meep_volume_contains);
  scm_c_define_gsubr("meep-volume-intersect-with", 2, 0, 0, (swig_guile_proc) _wrap_meep_volume_intersect_with);
  scm_c_define_gsubr("meep-volume-round-float", 1, 0, 0, (swig_guile_proc) _wrap_meep_volume_round_float);
  scm_c_define_gsubr("meep-volume-intersects", 2, 0, 0, (swig_guile_proc) _wrap_meep_volume_intersects);
  scm_c_define_gsubr("meep-volume-get-min-corner", 1, 0, 0, (swig_guile_proc) _wrap_meep_volume_get_min_corner);
  scm_c_define_gsubr("meep-volume-get-max-corner", 1, 0, 0, (swig_guile_proc) _wrap_meep_volume_get_max_corner);
  scm_c_define_gsubr("meep-volume-normal-direction", 1, 0, 0, (swig_guile_proc) _wrap_meep_volume_normal_direction);
  scm_c_define_gsubr("meep-volume-str", 0, 0, 1, (swig_guile_proc) _wrap_meep_volume_str);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__volume->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_volume;
  scm_c_define_gsubr("delete-meep-volume", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_volume);
  scm_c_define_gsubr("meep-volcyl", 3, 0, 0, (swig_guile_proc) _wrap_meep_volcyl);
  scm_c_define_gsubr("meep-volone", 2, 0, 0, (swig_guile_proc) _wrap_meep_volone);
  scm_c_define_gsubr("meep-vol1d", 2, 0, 0, (swig_guile_proc) _wrap_meep_vol1d);
  scm_c_define_gsubr("meep-voltwo", 3, 0, 0, (swig_guile_proc) _wrap_meep_voltwo);
  scm_c_define_gsubr("meep-vol2d", 3, 0, 0, (swig_guile_proc) _wrap_meep_vol2d);
  scm_c_define_gsubr("meep-vol3d", 4, 0, 0, (swig_guile_proc) _wrap_meep_vol3d);
  SWIG_TypeClientData(SWIGTYPE_p_meep__grid_volume, (void *) &_swig_guile_clientdatameep_grid_volume);
  scm_c_define_gsubr("new-meep-grid-volume", 0, 0, 0, (swig_guile_proc) _wrap_new_meep_grid_volume);
  scm_c_define_gsubr("meep-grid-volume-subvolume", 4, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_subvolume);
  scm_c_define_gsubr("meep-grid-volume-init-subvolume", 4, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_init_subvolume);
  scm_c_define_gsubr("meep-grid-volume-dim-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_dim_set);
  scm_c_define_gsubr("meep-grid-volume-dim-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_dim_get);
  scm_c_define_gsubr("meep-grid-volume-a-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_a_set);
  scm_c_define_gsubr("meep-grid-volume-a-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_a_get);
  scm_c_define_gsubr("meep-grid-volume-inva-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_inva_set);
  scm_c_define_gsubr("meep-grid-volume-inva-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_inva_get);
  scm_c_define_gsubr("meep-grid-volume-print", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_print);
  scm_c_define_gsubr("meep-grid-volume-stride", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_stride);
  scm_c_define_gsubr("meep-grid-volume-num-direction", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_num_direction);
  scm_c_define_gsubr("meep-grid-volume-yucky-num", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_yucky_num);
  scm_c_define_gsubr("meep-grid-volume-yucky-direction", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_yucky_direction);
  scm_c_define_gsubr("meep-grid-volume-set-num-direction", 3, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_set_num_direction);
  scm_c_define_gsubr("meep-grid-volume-nr", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_nr);
  scm_c_define_gsubr("meep-grid-volume-nx", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_nx);
  scm_c_define_gsubr("meep-grid-volume-ny", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_ny);
  scm_c_define_gsubr("meep-grid-volume-nz", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_nz);
  scm_c_define_gsubr("meep-grid-volume-has-field", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_has_field);
  scm_c_define_gsubr("meep-grid-volume-has-boundary", 3, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_has_boundary);
  scm_c_define_gsubr("meep-grid-volume-dr", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_dr);
  scm_c_define_gsubr("meep-grid-volume-dx", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_dx);
  scm_c_define_gsubr("meep-grid-volume-dy", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_dy);
  scm_c_define_gsubr("meep-grid-volume-dz", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_dz);
  scm_c_define_gsubr("meep-grid-volume-ntot", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_ntot);
  scm_c_define_gsubr("meep-grid-volume-nowned-min", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_nowned_min);
  scm_c_define_gsubr("meep-grid-volume-nowned", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_nowned);
  scm_c_define_gsubr("meep-grid-volume-index", 3, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_index);
  scm_c_define_gsubr("meep-grid-volume-round-vec", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_round_vec);
  scm_c_define_gsubr("meep-grid-volume-interpolate", 0, 0, 1, (swig_guile_proc) _wrap_meep_grid_volume_interpolate);
  scm_c_define_gsubr("meep-grid-volume-dV", 0, 0, 1, (swig_guile_proc) _wrap_meep_grid_volume_dV);
  scm_c_define_gsubr("meep-grid-volume-intersect-with", 0, 0, 1, (swig_guile_proc) _wrap_meep_grid_volume_intersect_with);
  scm_c_define_gsubr("meep-grid-volume-rmin", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_rmin);
  scm_c_define_gsubr("meep-grid-volume-rmax", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_rmax);
  scm_c_define_gsubr("meep-grid-volume-xmin", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_xmin);
  scm_c_define_gsubr("meep-grid-volume-xmax", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_xmax);
  scm_c_define_gsubr("meep-grid-volume-ymin", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_ymin);
  scm_c_define_gsubr("meep-grid-volume-ymax", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_ymax);
  scm_c_define_gsubr("meep-grid-volume-zmin", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_zmin);
  scm_c_define_gsubr("meep-grid-volume-zmax", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_zmax);
  scm_c_define_gsubr("meep-grid-volume-center", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_center);
  scm_c_define_gsubr("meep-grid-volume-icenter", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_icenter);
  scm_c_define_gsubr("meep-grid-volume-loc", 3, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_loc);
  scm_c_define_gsubr("meep-grid-volume-loc-at-resolution", 3, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_loc_at_resolution);
  scm_c_define_gsubr("meep-grid-volume-ntot-at-resolution", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_ntot_at_resolution);
  scm_c_define_gsubr("meep-grid-volume-iloc", 3, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_iloc);
  scm_c_define_gsubr("meep-grid-volume-surface-area", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_surface_area);
  scm_c_define_gsubr("meep-grid-volume-yee-index", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_yee_index);
  scm_c_define_gsubr("meep-grid-volume-yee-shift", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_yee_shift);
  scm_c_define_gsubr("meep-grid-volume-eps-component", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_eps_component);
  scm_c_define_gsubr("meep-grid-volume-yee2cent-offsets", 4, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_yee2cent_offsets);
  scm_c_define_gsubr("meep-grid-volume-cent2yee-offsets", 4, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_cent2yee_offsets);
  scm_c_define_gsubr("meep-grid-volume-boundary-location", 3, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_boundary_location);
  scm_c_define_gsubr("meep-grid-volume-big-corner", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_big_corner);
  scm_c_define_gsubr("meep-grid-volume-little-corner", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_little_corner);
  scm_c_define_gsubr("meep-grid-volume-corner", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_corner);
  scm_c_define_gsubr("meep-grid-volume-contains", 0, 0, 1, (swig_guile_proc) _wrap_meep_grid_volume_contains);
  scm_c_define_gsubr("meep-grid-volume-little-owned-corner0", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_little_owned_corner0);
  scm_c_define_gsubr("meep-grid-volume-little-owned-corner", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_little_owned_corner);
  scm_c_define_gsubr("meep-grid-volume-big-owned-corner", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_big_owned_corner);
  scm_c_define_gsubr("meep-grid-volume-owns", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_owns);
  scm_c_define_gsubr("meep-grid-volume-surroundings", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_surroundings);
  scm_c_define_gsubr("meep-grid-volume-interior", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_interior);
  scm_c_define_gsubr("meep-grid-volume-get-boundary-icorners", 5, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_get_boundary_icorners);
  scm_c_define_gsubr("meep-grid-volume-split-at-fraction", 4, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_split_at_fraction);
  scm_c_define_gsubr("meep-grid-volume-get-cost", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_get_cost);
  scm_c_define_gsubr("meep-grid-volume-halve", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_halve);
  scm_c_define_gsubr("meep-grid-volume-pad-self", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_pad_self);
  scm_c_define_gsubr("meep-grid-volume-pad", 0, 0, 1, (swig_guile_proc) _wrap_meep_grid_volume_pad);
  scm_c_define_gsubr("meep-grid-volume-iyee-shift", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_iyee_shift);
  scm_c_define_gsubr("meep-grid-volume-get-origin", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_get_origin);
  scm_c_define_gsubr("meep-grid-volume-shift-origin", 0, 0, 1, (swig_guile_proc) _wrap_meep_grid_volume_shift_origin);
  scm_c_define_gsubr("meep-grid-volume-set-origin", 0, 0, 1, (swig_guile_proc) _wrap_meep_grid_volume_set_origin);
  scm_c_define_gsubr("meep-grid-volume-center-origin", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_center_origin);
  scm_c_define_gsubr("meep-grid-volume-origin-in-direction", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_origin_in_direction);
  scm_c_define_gsubr("meep-grid-volume-iorigin-in-direction", 2, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_iorigin_in_direction);
  scm_c_define_gsubr("meep-grid-volume-origin-r", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_origin_r);
  scm_c_define_gsubr("meep-grid-volume-origin-x", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_origin_x);
  scm_c_define_gsubr("meep-grid-volume-origin-y", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_origin_y);
  scm_c_define_gsubr("meep-grid-volume-origin-z", 1, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_origin_z);
  scm_c_define_gsubr("meep-grid-volume-str", 0, 0, 1, (swig_guile_proc) _wrap_meep_grid_volume_str);
  scm_c_define_gsubr("meep-grid-volume-get-split-costs", 4, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_get_split_costs);
  scm_c_define_gsubr("meep-grid-volume-tile-split", 3, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_tile_split);
  scm_c_define_gsubr("meep-grid-volume-find-best-split", 6, 0, 0, (swig_guile_proc) _wrap_meep_grid_volume_find_best_split);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__grid_volume->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_grid_volume;
  scm_c_define_gsubr("delete-meep-grid-volume", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_grid_volume);
  scm_c_define_gsubr("meep-identity", 0, 0, 0, (swig_guile_proc) _wrap_meep_identity);
  scm_c_define_gsubr("meep-rotate4", 2, 0, 0, (swig_guile_proc) _wrap_meep_rotate4);
  scm_c_define_gsubr("meep-rotate2", 2, 0, 0, (swig_guile_proc) _wrap_meep_rotate2);
  scm_c_define_gsubr("meep-mirror", 2, 0, 0, (swig_guile_proc) _wrap_meep_mirror);
  scm_c_define_gsubr("meep-r-to-minus-r-symmetry", 1, 0, 0, (swig_guile_proc) _wrap_meep_r_to_minus_r_symmetry);
  SWIG_TypeClientData(SWIGTYPE_p_meep__symmetry, (void *) &_swig_guile_clientdatameep_symmetry);
  scm_c_define_gsubr("new-meep-symmetry", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_symmetry);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__symmetry->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_symmetry;
  scm_c_define_gsubr("delete-meep-symmetry", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_symmetry);
  scm_c_define_gsubr("meep-symmetry-transform-unshifted", 3, 0, 0, (swig_guile_proc) _wrap_meep_symmetry_transform_unshifted);
  scm_c_define_gsubr("meep-symmetry-transform", 0, 0, 1, (swig_guile_proc) _wrap_meep_symmetry_transform);
  scm_c_define_gsubr("meep-symmetry-phase-shift", 0, 0, 1, (swig_guile_proc) _wrap_meep_symmetry_phase_shift);
  scm_c_define_gsubr("meep-symmetry-multiplicity", 0, 0, 1, (swig_guile_proc) _wrap_meep_symmetry_multiplicity);
  scm_c_define_gsubr("meep-symmetry-is-primitive", 2, 0, 0, (swig_guile_proc) _wrap_meep_symmetry_is_primitive);
  scm_c_define_gsubr("meep-symmetry-reduce", 2, 0, 0, (swig_guile_proc) _wrap_meep_symmetry_reduce);
  scm_c_define_gsubr("meep-symmetry-meep-symmetry-add", 2, 0, 0, (swig_guile_proc) _wrap_meep_symmetry_meep_symmetry_add);
  scm_c_define_gsubr("meep-symmetry-meep-symmetry-mul", 2, 0, 0, (swig_guile_proc) _wrap_meep_symmetry_meep_symmetry_mul);
  scm_c_define_gsubr("meep-symmetry-meep-symmetry-sub", 0, 0, 1, (swig_guile_proc) _wrap_meep_symmetry_meep_symmetry_sub);
  scm_c_define_gsubr("meep-symmetry-meep-symmetry-eq", 2, 0, 0, (swig_guile_proc) _wrap_meep_symmetry_meep_symmetry_eq);
  scm_c_define_gsubr("meep-symmetry-meep-symmetry-neq", 2, 0, 0, (swig_guile_proc) _wrap_meep_symmetry_meep_symmetry_neq);
  scm_c_define_gsubr("meep-symmetry-i-symmetry-point-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_symmetry_i_symmetry_point_set);
  scm_c_define_gsubr("meep-symmetry-i-symmetry-point-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_symmetry_i_symmetry_point_get);
  SWIG_TypeClientData(SWIGTYPE_p_meep__volume_list, (void *) &_swig_guile_clientdatameep_volume_list);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__volume_list->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_volume_list;
  scm_c_define_gsubr("delete-meep-volume-list", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_volume_list);
  scm_c_define_gsubr("new-meep-volume-list", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_volume_list);
  scm_c_define_gsubr("meep-volume-list-v-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_volume_list_v_set);
  scm_c_define_gsubr("meep-volume-list-v-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_volume_list_v_get);
  scm_c_define_gsubr("meep-volume-list-c-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_volume_list_c_set);
  scm_c_define_gsubr("meep-volume-list-c-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_volume_list_c_get);
  scm_c_define_gsubr("meep-volume-list-weight-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_volume_list_weight_set);
  scm_c_define_gsubr("meep-volume-list-weight-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_volume_list_weight_get);
  scm_c_define_gsubr("meep-volume-list-next-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_volume_list_next_set);
  scm_c_define_gsubr("meep-volume-list-next-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_volume_list_next_get);
  scm_c_define_gsubr("meep-wall-time", 0, 0, 0, (swig_guile_proc) _wrap_meep_wall_time);
  SWIG_TypeClientData(SWIGTYPE_p_meep__initialize, (void *) &_swig_guile_clientdatameep_initialize);
  scm_c_define_gsubr("new-meep-initialize", 2, 0, 0, (swig_guile_proc) _wrap_new_meep_initialize);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__initialize->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_initialize;
  scm_c_define_gsubr("delete-meep-initialize", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_initialize);
  scm_c_define_gsubr("meep-initialize-elapsed-time", 1, 0, 0, (swig_guile_proc) _wrap_meep_initialize_elapsed_time);
  scm_c_define_gsubr("meep-all-wait", 0, 0, 0, (swig_guile_proc) _wrap_meep_all_wait);
  scm_c_define_gsubr("meep-count-processors", 0, 0, 0, (swig_guile_proc) _wrap_meep_count_processors);
  scm_c_define_gsubr("meep-my-rank", 0, 0, 0, (swig_guile_proc) _wrap_meep_my_rank);
  scm_c_define_gsubr("meep-am-really-master", 0, 0, 0, (swig_guile_proc) _wrap_meep_am_really_master);
  scm_c_define_gsubr("meep-am-master", 0, 0, 0, (swig_guile_proc) _wrap_meep_am_master);
  scm_c_define_gsubr("meep-with-mpi", 0, 0, 0, (swig_guile_proc) _wrap_meep_with_mpi);
  scm_c_define_gsubr("meep-send", 0, 0, 1, (swig_guile_proc) _wrap_meep_send);
  scm_c_define_gsubr("meep-broadcast", 0, 0, 1, (swig_guile_proc) _wrap_meep_broadcast);
  scm_c_define_gsubr("meep-max-to-master", 1, 0, 0, (swig_guile_proc) _wrap_meep_max_to_master);
  scm_c_define_gsubr("meep-max-to-all", 0, 0, 1, (swig_guile_proc) _wrap_meep_max_to_all);
  scm_c_define_gsubr("meep-min-to-all", 1, 0, 0, (swig_guile_proc) _wrap_meep_min_to_all);
  scm_c_define_gsubr("meep-partial-sum-to-all", 0, 0, 1, (swig_guile_proc) _wrap_meep_partial_sum_to_all);
  scm_c_define_gsubr("meep-sum-to-all", 0, 0, 1, (swig_guile_proc) _wrap_meep_sum_to_all);
  scm_c_define_gsubr("meep-sum-to-master", 0, 0, 1, (swig_guile_proc) _wrap_meep_sum_to_master);
  scm_c_define_gsubr("meep-or-to-all", 0, 0, 1, (swig_guile_proc) _wrap_meep_or_to_all);
  scm_c_define_gsubr("meep-bw-or-to-all", 3, 0, 0, (swig_guile_proc) _wrap_meep_bw_or_to_all);
  scm_c_define_gsubr("meep-and-to-all", 0, 0, 1, (swig_guile_proc) _wrap_meep_and_to_all);
  scm_c_define_gsubr("meep-master-printf", 1, 0, 0, (swig_guile_proc) _wrap_meep_master_printf);
  scm_c_define_gsubr("meep-master-printf-stderr", 1, 0, 0, (swig_guile_proc) _wrap_meep_master_printf_stderr);
  scm_c_define_gsubr("meep-debug-printf", 1, 0, 0, (swig_guile_proc) _wrap_meep_debug_printf);
  scm_c_define_gsubr("meep-master-fprintf", 2, 0, 0, (swig_guile_proc) _wrap_meep_master_fprintf);
  scm_c_define_gsubr("meep-master-fopen", 2, 0, 0, (swig_guile_proc) _wrap_meep_master_fopen);
  scm_c_define_gsubr("meep-master-fclose", 1, 0, 0, (swig_guile_proc) _wrap_meep_master_fclose);
  scm_c_define_gsubr("meep-set-meep-printf-callback", 1, 0, 0, (swig_guile_proc) _wrap_meep_set_meep_printf_callback);
  scm_c_define_gsubr("meep-set-meep-printf-stderr-callback", 1, 0, 0, (swig_guile_proc) _wrap_meep_set_meep_printf_stderr_callback);
  scm_c_define_gsubr("meep-begin-critical-section", 1, 0, 0, (swig_guile_proc) _wrap_meep_begin_critical_section);
  scm_c_define_gsubr("meep-end-critical-section", 1, 0, 0, (swig_guile_proc) _wrap_meep_end_critical_section);
  scm_c_define_gsubr("meep-divide-parallel-processes", 1, 0, 0, (swig_guile_proc) _wrap_meep_divide_parallel_processes);
  scm_c_define_gsubr("meep-begin-global-communications", 0, 0, 0, (swig_guile_proc) _wrap_meep_begin_global_communications);
  scm_c_define_gsubr("meep-end-global-communications", 0, 0, 0, (swig_guile_proc) _wrap_meep_end_global_communications);
  scm_c_define_gsubr("meep-end-divide-parallel", 0, 0, 0, (swig_guile_proc) _wrap_meep_end_divide_parallel);
  scm_c_define_gsubr("meep-my-global-rank", 0, 0, 0, (swig_guile_proc) _wrap_meep_my_global_rank);
  scm_c_define_gsubr("MEEP-MIN-OUTPUT-TIME", 0, 0, 0, (swig_guile_proc) _wrap_MEEP_MIN_OUTPUT_TIME);
  scm_c_define_gsubr("verbosity", 0, 1, 0, (swig_guile_proc) _wrap_verbosity);
  scm_c_define_gsubr("pi", 0, 0, 0, (swig_guile_proc) _wrap_pi);
  scm_c_define_gsubr("infinity", 0, 0, 0, (swig_guile_proc) _wrap_infinity);
  scm_c_define_gsubr("nan", 0, 0, 0, (swig_guile_proc) _wrap_nan);
  scm_c_define_gsubr("meep-cdouble", 0, 0, 1, (swig_guile_proc) _wrap_meep_cdouble);
  scm_c_define_gsubr("meep-matrix-invert", 2, 0, 0, (swig_guile_proc) _wrap_meep_matrix_invert);
  scm_c_define_gsubr("meep-linspace", 3, 0, 0, (swig_guile_proc) _wrap_meep_linspace);
  scm_c_define_gsubr("meep-pml-quadratic-profile", 2, 0, 0, (swig_guile_proc) _wrap_meep_pml_quadratic_profile);
  SWIG_TypeClientData(SWIGTYPE_p_meep__susceptibility, (void *) &_swig_guile_clientdatameep_susceptibility);
  scm_c_define_gsubr("new-meep-susceptibility", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_susceptibility);
  scm_c_define_gsubr("meep-susceptibility-clone", 1, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_clone);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__susceptibility->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_susceptibility;
  scm_c_define_gsubr("delete-meep-susceptibility", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_susceptibility);
  scm_c_define_gsubr("meep-susceptibility-get-id", 1, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_get_id);
  scm_c_define_gsubr("meep-susceptibility-chi1", 0, 0, 1, (swig_guile_proc) _wrap_meep_susceptibility_chi1);
  scm_c_define_gsubr("meep-susceptibility-update-P", 6, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_update_P);
  scm_c_define_gsubr("meep-susceptibility-subtract-P", 4, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_subtract_P);
  scm_c_define_gsubr("meep-susceptibility-needs-P", 4, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_needs_P);
  scm_c_define_gsubr("meep-susceptibility-needs-W-notowned", 3, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_needs_W_notowned);
  scm_c_define_gsubr("meep-susceptibility-needs-W-prev", 1, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_needs_W_prev);
  scm_c_define_gsubr("meep-susceptibility-new-internal-data", 3, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_new_internal_data);
  scm_c_define_gsubr("meep-susceptibility-delete-internal-data", 2, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_delete_internal_data);
  scm_c_define_gsubr("meep-susceptibility-init-internal-data", 5, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_init_internal_data);
  scm_c_define_gsubr("meep-susceptibility-copy-internal-data", 2, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_copy_internal_data);
  scm_c_define_gsubr("meep-susceptibility-num-internal-notowned-needed", 3, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_num_internal_notowned_needed);
  scm_c_define_gsubr("meep-susceptibility-internal-notowned-ptr", 5, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_internal_notowned_ptr);
  scm_c_define_gsubr("meep-susceptibility-num-cinternal-notowned-needed", 3, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_num_cinternal_notowned_needed);
  scm_c_define_gsubr("meep-susceptibility-cinternal-notowned-ptr", 6, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_cinternal_notowned_ptr);
  scm_c_define_gsubr("meep-susceptibility-dump-params", 3, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_dump_params);
  scm_c_define_gsubr("meep-susceptibility-get-num-params", 1, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_get_num_params);
  scm_c_define_gsubr("meep-susceptibility-set-id", 2, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_set_id);
  scm_c_define_gsubr("meep-susceptibility-next-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_next_set);
  scm_c_define_gsubr("meep-susceptibility-next-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_next_get);
  scm_c_define_gsubr("meep-susceptibility-ntot-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_ntot_set);
  scm_c_define_gsubr("meep-susceptibility-ntot-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_ntot_get);
  scm_c_define_gsubr("meep-susceptibility-sigma-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_sigma_set);
  scm_c_define_gsubr("meep-susceptibility-sigma-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_sigma_get);
  scm_c_define_gsubr("meep-susceptibility-trivial-sigma-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_trivial_sigma_set);
  scm_c_define_gsubr("meep-susceptibility-trivial-sigma-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_susceptibility_trivial_sigma_get);
  SWIG_TypeClientData(SWIGTYPE_p_meep__lorentzian_susceptibility, (void *) &_swig_guile_clientdatameep_lorentzian_susceptibility);
  scm_c_define_gsubr("new-meep-lorentzian-susceptibility", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_lorentzian_susceptibility);
  scm_c_define_gsubr("meep-lorentzian-susceptibility-clone", 1, 0, 0, (swig_guile_proc) _wrap_meep_lorentzian_susceptibility_clone);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__lorentzian_susceptibility->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_lorentzian_susceptibility;
  scm_c_define_gsubr("delete-meep-lorentzian-susceptibility", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_lorentzian_susceptibility);
  scm_c_define_gsubr("meep-lorentzian-susceptibility-chi1", 0, 0, 1, (swig_guile_proc) _wrap_meep_lorentzian_susceptibility_chi1);
  scm_c_define_gsubr("meep-lorentzian-susceptibility-update-P", 6, 0, 0, (swig_guile_proc) _wrap_meep_lorentzian_susceptibility_update_P);
  scm_c_define_gsubr("meep-lorentzian-susceptibility-subtract-P", 4, 0, 0, (swig_guile_proc) _wrap_meep_lorentzian_susceptibility_subtract_P);
  scm_c_define_gsubr("meep-lorentzian-susceptibility-new-internal-data", 3, 0, 0, (swig_guile_proc) _wrap_meep_lorentzian_susceptibility_new_internal_data);
  scm_c_define_gsubr("meep-lorentzian-susceptibility-init-internal-data", 5, 0, 0, (swig_guile_proc) _wrap_meep_lorentzian_susceptibility_init_internal_data);
  scm_c_define_gsubr("meep-lorentzian-susceptibility-copy-internal-data", 2, 0, 0, (swig_guile_proc) _wrap_meep_lorentzian_susceptibility_copy_internal_data);
  scm_c_define_gsubr("meep-lorentzian-susceptibility-num-cinternal-notowned-needed", 3, 0, 0, (swig_guile_proc) _wrap_meep_lorentzian_susceptibility_num_cinternal_notowned_needed);
  scm_c_define_gsubr("meep-lorentzian-susceptibility-cinternal-notowned-ptr", 6, 0, 0, (swig_guile_proc) _wrap_meep_lorentzian_susceptibility_cinternal_notowned_ptr);
  scm_c_define_gsubr("meep-lorentzian-susceptibility-dump-params", 3, 0, 0, (swig_guile_proc) _wrap_meep_lorentzian_susceptibility_dump_params);
  scm_c_define_gsubr("meep-lorentzian-susceptibility-get-num-params", 1, 0, 0, (swig_guile_proc) _wrap_meep_lorentzian_susceptibility_get_num_params);
  SWIG_TypeClientData(SWIGTYPE_p_meep__noisy_lorentzian_susceptibility, (void *) &_swig_guile_clientdatameep_noisy_lorentzian_susceptibility);
  scm_c_define_gsubr("new-meep-noisy-lorentzian-susceptibility", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_noisy_lorentzian_susceptibility);
  scm_c_define_gsubr("meep-noisy-lorentzian-susceptibility-clone", 1, 0, 0, (swig_guile_proc) _wrap_meep_noisy_lorentzian_susceptibility_clone);
  scm_c_define_gsubr("meep-noisy-lorentzian-susceptibility-update-P", 6, 0, 0, (swig_guile_proc) _wrap_meep_noisy_lorentzian_susceptibility_update_P);
  scm_c_define_gsubr("meep-noisy-lorentzian-susceptibility-dump-params", 3, 0, 0, (swig_guile_proc) _wrap_meep_noisy_lorentzian_susceptibility_dump_params);
  scm_c_define_gsubr("meep-noisy-lorentzian-susceptibility-get-num-params", 1, 0, 0, (swig_guile_proc) _wrap_meep_noisy_lorentzian_susceptibility_get_num_params);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__noisy_lorentzian_susceptibility->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_noisy_lorentzian_susceptibility;
  scm_c_define_gsubr("delete-meep-noisy-lorentzian-susceptibility", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_noisy_lorentzian_susceptibility);
  scm_c_define_gsubr("GYROTROPIC-LORENTZIAN", 0, 0, 0, (swig_guile_proc) _wrap_GYROTROPIC_LORENTZIAN);
  scm_c_define_gsubr("GYROTROPIC-DRUDE", 0, 0, 0, (swig_guile_proc) _wrap_GYROTROPIC_DRUDE);
  scm_c_define_gsubr("GYROTROPIC-SATURATED", 0, 0, 0, (swig_guile_proc) _wrap_GYROTROPIC_SATURATED);
  SWIG_TypeClientData(SWIGTYPE_p_meep__gyrotropic_susceptibility, (void *) &_swig_guile_clientdatameep_gyrotropic_susceptibility);
  scm_c_define_gsubr("new-meep-gyrotropic-susceptibility", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_gyrotropic_susceptibility);
  scm_c_define_gsubr("meep-gyrotropic-susceptibility-clone", 1, 0, 0, (swig_guile_proc) _wrap_meep_gyrotropic_susceptibility_clone);
  scm_c_define_gsubr("meep-gyrotropic-susceptibility-new-internal-data", 3, 0, 0, (swig_guile_proc) _wrap_meep_gyrotropic_susceptibility_new_internal_data);
  scm_c_define_gsubr("meep-gyrotropic-susceptibility-init-internal-data", 5, 0, 0, (swig_guile_proc) _wrap_meep_gyrotropic_susceptibility_init_internal_data);
  scm_c_define_gsubr("meep-gyrotropic-susceptibility-copy-internal-data", 2, 0, 0, (swig_guile_proc) _wrap_meep_gyrotropic_susceptibility_copy_internal_data);
  scm_c_define_gsubr("meep-gyrotropic-susceptibility-needs-P", 4, 0, 0, (swig_guile_proc) _wrap_meep_gyrotropic_susceptibility_needs_P);
  scm_c_define_gsubr("meep-gyrotropic-susceptibility-update-P", 6, 0, 0, (swig_guile_proc) _wrap_meep_gyrotropic_susceptibility_update_P);
  scm_c_define_gsubr("meep-gyrotropic-susceptibility-subtract-P", 4, 0, 0, (swig_guile_proc) _wrap_meep_gyrotropic_susceptibility_subtract_P);
  scm_c_define_gsubr("meep-gyrotropic-susceptibility-num-cinternal-notowned-needed", 3, 0, 0, (swig_guile_proc) _wrap_meep_gyrotropic_susceptibility_num_cinternal_notowned_needed);
  scm_c_define_gsubr("meep-gyrotropic-susceptibility-cinternal-notowned-ptr", 6, 0, 0, (swig_guile_proc) _wrap_meep_gyrotropic_susceptibility_cinternal_notowned_ptr);
  scm_c_define_gsubr("meep-gyrotropic-susceptibility-dump-params", 3, 0, 0, (swig_guile_proc) _wrap_meep_gyrotropic_susceptibility_dump_params);
  scm_c_define_gsubr("meep-gyrotropic-susceptibility-get-num-params", 1, 0, 0, (swig_guile_proc) _wrap_meep_gyrotropic_susceptibility_get_num_params);
  scm_c_define_gsubr("meep-gyrotropic-susceptibility-needs-W-notowned", 3, 0, 0, (swig_guile_proc) _wrap_meep_gyrotropic_susceptibility_needs_W_notowned);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__gyrotropic_susceptibility->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_gyrotropic_susceptibility;
  scm_c_define_gsubr("delete-meep-gyrotropic-susceptibility", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_gyrotropic_susceptibility);
  SWIG_TypeClientData(SWIGTYPE_p_meep__multilevel_susceptibility, (void *) &_swig_guile_clientdatameep_multilevel_susceptibility);
  scm_c_define_gsubr("new-meep-multilevel-susceptibility", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_multilevel_susceptibility);
  scm_c_define_gsubr("meep-multilevel-susceptibility-clone", 1, 0, 0, (swig_guile_proc) _wrap_meep_multilevel_susceptibility_clone);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__multilevel_susceptibility->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_multilevel_susceptibility;
  scm_c_define_gsubr("delete-meep-multilevel-susceptibility", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_multilevel_susceptibility);
  scm_c_define_gsubr("meep-multilevel-susceptibility-update-P", 6, 0, 0, (swig_guile_proc) _wrap_meep_multilevel_susceptibility_update_P);
  scm_c_define_gsubr("meep-multilevel-susceptibility-subtract-P", 4, 0, 0, (swig_guile_proc) _wrap_meep_multilevel_susceptibility_subtract_P);
  scm_c_define_gsubr("meep-multilevel-susceptibility-new-internal-data", 3, 0, 0, (swig_guile_proc) _wrap_meep_multilevel_susceptibility_new_internal_data);
  scm_c_define_gsubr("meep-multilevel-susceptibility-init-internal-data", 5, 0, 0, (swig_guile_proc) _wrap_meep_multilevel_susceptibility_init_internal_data);
  scm_c_define_gsubr("meep-multilevel-susceptibility-copy-internal-data", 2, 0, 0, (swig_guile_proc) _wrap_meep_multilevel_susceptibility_copy_internal_data);
  scm_c_define_gsubr("meep-multilevel-susceptibility-delete-internal-data", 2, 0, 0, (swig_guile_proc) _wrap_meep_multilevel_susceptibility_delete_internal_data);
  scm_c_define_gsubr("meep-multilevel-susceptibility-num-cinternal-notowned-needed", 3, 0, 0, (swig_guile_proc) _wrap_meep_multilevel_susceptibility_num_cinternal_notowned_needed);
  scm_c_define_gsubr("meep-multilevel-susceptibility-cinternal-notowned-ptr", 6, 0, 0, (swig_guile_proc) _wrap_meep_multilevel_susceptibility_cinternal_notowned_ptr);
  scm_c_define_gsubr("meep-multilevel-susceptibility-needs-W-notowned", 3, 0, 0, (swig_guile_proc) _wrap_meep_multilevel_susceptibility_needs_W_notowned);
  scm_c_define_gsubr("meep-multilevel-susceptibility-needs-W-prev", 1, 0, 0, (swig_guile_proc) _wrap_meep_multilevel_susceptibility_needs_W_prev);
  SWIG_TypeClientData(SWIGTYPE_p_meep__h5file, (void *) &_swig_guile_clientdatameep_h5file);
  scm_c_define_gsubr("meep-h5file-READONLY", 0, 0, 0, (swig_guile_proc) _wrap_meep_h5file_READONLY);
  scm_c_define_gsubr("meep-h5file-READWRITE", 0, 0, 0, (swig_guile_proc) _wrap_meep_h5file_READWRITE);
  scm_c_define_gsubr("meep-h5file-WRITE", 0, 0, 0, (swig_guile_proc) _wrap_meep_h5file_WRITE);
  scm_c_define_gsubr("new-meep-h5file", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_h5file);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__h5file->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_h5file;
  scm_c_define_gsubr("delete-meep-h5file", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_h5file);
  scm_c_define_gsubr("meep-h5file-ok", 1, 0, 0, (swig_guile_proc) _wrap_meep_h5file_ok);
  scm_c_define_gsubr("meep-h5file-read", 0, 0, 1, (swig_guile_proc) _wrap_meep_h5file_read);
  scm_c_define_gsubr("meep-h5file-write", 0, 0, 1, (swig_guile_proc) _wrap_meep_h5file_write);
  scm_c_define_gsubr("meep-h5file-create-data", 0, 0, 1, (swig_guile_proc) _wrap_meep_h5file_create_data);
  scm_c_define_gsubr("meep-h5file-extend-data", 4, 0, 0, (swig_guile_proc) _wrap_meep_h5file_extend_data);
  scm_c_define_gsubr("meep-h5file-create-or-extend-data", 0, 0, 1, (swig_guile_proc) _wrap_meep_h5file_create_or_extend_data);
  scm_c_define_gsubr("meep-h5file-write-chunk", 0, 0, 1, (swig_guile_proc) _wrap_meep_h5file_write_chunk);
  scm_c_define_gsubr("meep-h5file-done-writing-chunks", 1, 0, 0, (swig_guile_proc) _wrap_meep_h5file_done_writing_chunks);
  scm_c_define_gsubr("meep-h5file-read-size", 5, 0, 0, (swig_guile_proc) _wrap_meep_h5file_read_size);
  scm_c_define_gsubr("meep-h5file-read-chunk", 0, 0, 1, (swig_guile_proc) _wrap_meep_h5file_read_chunk);
  scm_c_define_gsubr("meep-h5file-remove", 1, 0, 0, (swig_guile_proc) _wrap_meep_h5file_remove);
  scm_c_define_gsubr("meep-h5file-remove-data", 2, 0, 0, (swig_guile_proc) _wrap_meep_h5file_remove_data);
  scm_c_define_gsubr("meep-h5file-file-name", 1, 0, 0, (swig_guile_proc) _wrap_meep_h5file_file_name);
  scm_c_define_gsubr("meep-h5file-prevent-deadlock", 1, 0, 0, (swig_guile_proc) _wrap_meep_h5file_prevent_deadlock);
  scm_c_define_gsubr("meep-h5file-dataset-exists", 2, 0, 0, (swig_guile_proc) _wrap_meep_h5file_dataset_exists);
  scm_c_define_gsubr("meep-h5file-extending-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_h5file_extending_set);
  scm_c_define_gsubr("meep-h5file-extending-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_h5file_extending_get);
  scm_c_define_gsubr("meep-h5file-get-extending", 2, 0, 0, (swig_guile_proc) _wrap_meep_h5file_get_extending);
  scm_c_define_gsubr("DEFAULT-SUBPIXEL-TOL", 0, 0, 0, (swig_guile_proc) _wrap_DEFAULT_SUBPIXEL_TOL);
  scm_c_define_gsubr("DEFAULT-SUBPIXEL-MAXEVAL", 0, 0, 0, (swig_guile_proc) _wrap_DEFAULT_SUBPIXEL_MAXEVAL);
  SWIG_TypeClientData(SWIGTYPE_p_meep__material_function, (void *) &_swig_guile_clientdatameep_material_function);
  scm_c_define_gsubr("new-meep-material-function", 0, 0, 0, (swig_guile_proc) _wrap_new_meep_material_function);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__material_function->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_material_function;
  scm_c_define_gsubr("delete-meep-material-function", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_material_function);
  scm_c_define_gsubr("meep-material-function-set-volume", 2, 0, 0, (swig_guile_proc) _wrap_meep_material_function_set_volume);
  scm_c_define_gsubr("meep-material-function-unset-volume", 1, 0, 0, (swig_guile_proc) _wrap_meep_material_function_unset_volume);
  scm_c_define_gsubr("meep-material-function-chi1p1", 3, 0, 0, (swig_guile_proc) _wrap_meep_material_function_chi1p1);
  scm_c_define_gsubr("meep-material-function-eps", 2, 0, 0, (swig_guile_proc) _wrap_meep_material_function_eps);
  scm_c_define_gsubr("meep-material-function-has-mu", 1, 0, 0, (swig_guile_proc) _wrap_meep_material_function_has_mu);
  scm_c_define_gsubr("meep-material-function-mu", 2, 0, 0, (swig_guile_proc) _wrap_meep_material_function_mu);
  scm_c_define_gsubr("meep-material-function-has-conductivity", 2, 0, 0, (swig_guile_proc) _wrap_meep_material_function_has_conductivity);
  scm_c_define_gsubr("meep-material-function-conductivity", 3, 0, 0, (swig_guile_proc) _wrap_meep_material_function_conductivity);
  scm_c_define_gsubr("meep-material-function-normal-vector", 3, 0, 0, (swig_guile_proc) _wrap_meep_material_function_normal_vector);
  scm_c_define_gsubr("meep-material-function-eff-chi1inv-row", 0, 0, 1, (swig_guile_proc) _wrap_meep_material_function_eff_chi1inv_row);
  scm_c_define_gsubr("meep-material-function-sigma-row", 4, 0, 0, (swig_guile_proc) _wrap_meep_material_function_sigma_row);
  scm_c_define_gsubr("meep-material-function-has-chi3", 2, 0, 0, (swig_guile_proc) _wrap_meep_material_function_has_chi3);
  scm_c_define_gsubr("meep-material-function-chi3", 3, 0, 0, (swig_guile_proc) _wrap_meep_material_function_chi3);
  scm_c_define_gsubr("meep-material-function-has-chi2", 2, 0, 0, (swig_guile_proc) _wrap_meep_material_function_has_chi2);
  scm_c_define_gsubr("meep-material-function-chi2", 3, 0, 0, (swig_guile_proc) _wrap_meep_material_function_chi2);
  SWIG_TypeClientData(SWIGTYPE_p_meep__simple_material_function, (void *) &_swig_guile_clientdatameep_simple_material_function);
  scm_c_define_gsubr("new-meep-simple-material-function", 1, 0, 0, (swig_guile_proc) _wrap_new_meep_simple_material_function);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__simple_material_function->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_simple_material_function;
  scm_c_define_gsubr("delete-meep-simple-material-function", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_simple_material_function);
  scm_c_define_gsubr("meep-simple-material-function-chi1p1", 3, 0, 0, (swig_guile_proc) _wrap_meep_simple_material_function_chi1p1);
  scm_c_define_gsubr("meep-simple-material-function-eps", 2, 0, 0, (swig_guile_proc) _wrap_meep_simple_material_function_eps);
  scm_c_define_gsubr("meep-simple-material-function-mu", 2, 0, 0, (swig_guile_proc) _wrap_meep_simple_material_function_mu);
  scm_c_define_gsubr("meep-simple-material-function-conductivity", 3, 0, 0, (swig_guile_proc) _wrap_meep_simple_material_function_conductivity);
  scm_c_define_gsubr("meep-simple-material-function-sigma-row", 4, 0, 0, (swig_guile_proc) _wrap_meep_simple_material_function_sigma_row);
  scm_c_define_gsubr("meep-simple-material-function-chi3", 3, 0, 0, (swig_guile_proc) _wrap_meep_simple_material_function_chi3);
  scm_c_define_gsubr("meep-simple-material-function-chi2", 3, 0, 0, (swig_guile_proc) _wrap_meep_simple_material_function_chi2);
  SWIG_TypeClientData(SWIGTYPE_p_meep__structure_chunk, (void *) &_swig_guile_clientdatameep_structure_chunk);
  scm_c_define_gsubr("meep-structure-chunk-a-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_a_set);
  scm_c_define_gsubr("meep-structure-chunk-a-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_a_get);
  scm_c_define_gsubr("meep-structure-chunk-Courant-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_Courant_set);
  scm_c_define_gsubr("meep-structure-chunk-Courant-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_Courant_get);
  scm_c_define_gsubr("meep-structure-chunk-dt-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_dt_set);
  scm_c_define_gsubr("meep-structure-chunk-dt-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_dt_get);
  scm_c_define_gsubr("meep-structure-chunk-chi3-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_chi3_set);
  scm_c_define_gsubr("meep-structure-chunk-chi3-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_chi3_get);
  scm_c_define_gsubr("meep-structure-chunk-chi2-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_chi2_set);
  scm_c_define_gsubr("meep-structure-chunk-chi2-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_chi2_get);
  scm_c_define_gsubr("meep-structure-chunk-chi1inv-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_chi1inv_set);
  scm_c_define_gsubr("meep-structure-chunk-chi1inv-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_chi1inv_get);
  scm_c_define_gsubr("meep-structure-chunk-trivial-chi1inv-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_trivial_chi1inv_set);
  scm_c_define_gsubr("meep-structure-chunk-trivial-chi1inv-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_trivial_chi1inv_get);
  scm_c_define_gsubr("meep-structure-chunk-conductivity-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_conductivity_set);
  scm_c_define_gsubr("meep-structure-chunk-conductivity-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_conductivity_get);
  scm_c_define_gsubr("meep-structure-chunk-condinv-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_condinv_set);
  scm_c_define_gsubr("meep-structure-chunk-condinv-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_condinv_get);
  scm_c_define_gsubr("meep-structure-chunk-condinv-stale-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_condinv_stale_set);
  scm_c_define_gsubr("meep-structure-chunk-condinv-stale-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_condinv_stale_get);
  scm_c_define_gsubr("meep-structure-chunk-sig-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_sig_set);
  scm_c_define_gsubr("meep-structure-chunk-sig-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_sig_get);
  scm_c_define_gsubr("meep-structure-chunk-kap-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_kap_set);
  scm_c_define_gsubr("meep-structure-chunk-kap-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_kap_get);
  scm_c_define_gsubr("meep-structure-chunk-siginv-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_siginv_set);
  scm_c_define_gsubr("meep-structure-chunk-siginv-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_siginv_get);
  scm_c_define_gsubr("meep-structure-chunk-sigsize-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_sigsize_set);
  scm_c_define_gsubr("meep-structure-chunk-sigsize-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_sigsize_get);
  scm_c_define_gsubr("meep-structure-chunk-gv-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_gv_set);
  scm_c_define_gsubr("meep-structure-chunk-gv-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_gv_get);
  scm_c_define_gsubr("meep-structure-chunk-v-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_v_set);
  scm_c_define_gsubr("meep-structure-chunk-v-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_v_get);
  scm_c_define_gsubr("meep-structure-chunk-chiP-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_chiP_set);
  scm_c_define_gsubr("meep-structure-chunk-chiP-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_chiP_get);
  scm_c_define_gsubr("meep-structure-chunk-cost-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_cost_set);
  scm_c_define_gsubr("meep-structure-chunk-cost-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_cost_get);
  scm_c_define_gsubr("meep-structure-chunk-refcount-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_refcount_set);
  scm_c_define_gsubr("meep-structure-chunk-refcount-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_refcount_get);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__structure_chunk->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_structure_chunk;
  scm_c_define_gsubr("delete-meep-structure-chunk", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_structure_chunk);
  scm_c_define_gsubr("new-meep-structure-chunk", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_structure_chunk);
  scm_c_define_gsubr("meep-structure-chunk-set-chi1inv", 6, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_set_chi1inv);
  scm_c_define_gsubr("meep-structure-chunk-has-chi", 3, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_has_chi);
  scm_c_define_gsubr("meep-structure-chunk-has-chisigma", 3, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_has_chisigma);
  scm_c_define_gsubr("meep-structure-chunk-has-chi1inv", 3, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_has_chi1inv);
  scm_c_define_gsubr("meep-structure-chunk-set-conductivity", 3, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_set_conductivity);
  scm_c_define_gsubr("meep-structure-chunk-update-condinv", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_update_condinv);
  scm_c_define_gsubr("meep-structure-chunk-set-chi3", 3, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_set_chi3);
  scm_c_define_gsubr("meep-structure-chunk-set-chi2", 3, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_set_chi2);
  scm_c_define_gsubr("meep-structure-chunk-use-pml", 10, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_use_pml);
  scm_c_define_gsubr("meep-structure-chunk-add-susceptibility", 4, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_add_susceptibility);
  scm_c_define_gsubr("meep-structure-chunk-mix-with", 3, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_mix_with);
  scm_c_define_gsubr("meep-structure-chunk-n-proc", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_n_proc);
  scm_c_define_gsubr("meep-structure-chunk-is-mine", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_is_mine);
  scm_c_define_gsubr("meep-structure-chunk-remove-susceptibilities", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_remove_susceptibilities);
  scm_c_define_gsubr("meep-structure-chunk-get-chi1inv-at-pt", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_chunk_get_chi1inv_at_pt);
  scm_c_define_gsubr("meep-structure-chunk-get-chi1inv", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_chunk_get_chi1inv);
  scm_c_define_gsubr("meep-structure-chunk-get-inveps", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_chunk_get_inveps);
  scm_c_define_gsubr("meep-structure-chunk-max-eps", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunk_max_eps);
  SWIG_TypeClientData(SWIGTYPE_p_meep__boundary_region, (void *) &_swig_guile_clientdatameep_boundary_region);
  scm_c_define_gsubr("meep-boundary-region-NOTHING-SPECIAL", 0, 0, 0, (swig_guile_proc) _wrap_meep_boundary_region_NOTHING_SPECIAL);
  scm_c_define_gsubr("meep-boundary-region-PML", 0, 0, 0, (swig_guile_proc) _wrap_meep_boundary_region_PML);
  scm_c_define_gsubr("new-meep-boundary-region", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_boundary_region);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__boundary_region->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_boundary_region;
  scm_c_define_gsubr("delete-meep-boundary-region", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_boundary_region);
  scm_c_define_gsubr("meep-boundary-region-meep-boundary-region-add", 2, 0, 0, (swig_guile_proc) _wrap_meep_boundary_region_meep_boundary_region_add);
  scm_c_define_gsubr("meep-boundary-region-meep-boundary-region-mul", 2, 0, 0, (swig_guile_proc) _wrap_meep_boundary_region_meep_boundary_region_mul);
  scm_c_define_gsubr("meep-boundary-region-apply", 0, 0, 1, (swig_guile_proc) _wrap_meep_boundary_region_apply);
  scm_c_define_gsubr("meep-boundary-region-check-ok", 2, 0, 0, (swig_guile_proc) _wrap_meep_boundary_region_check_ok);
  scm_c_define_gsubr("meep-pml", 0, 0, 1, (swig_guile_proc) _wrap_meep_pml);
  scm_c_define_gsubr("meep-in-or-out-Incoming", 0, 0, 0, (swig_guile_proc) _wrap_meep_in_or_out_Incoming);
  scm_c_define_gsubr("meep-in-or-out-Outgoing", 0, 0, 0, (swig_guile_proc) _wrap_meep_in_or_out_Outgoing);
  scm_c_define_gsubr("meep-connect-phase-CONNECT-PHASE", 0, 0, 0, (swig_guile_proc) _wrap_meep_connect_phase_CONNECT_PHASE);
  scm_c_define_gsubr("meep-connect-phase-CONNECT-NEGATE", 0, 0, 0, (swig_guile_proc) _wrap_meep_connect_phase_CONNECT_NEGATE);
  scm_c_define_gsubr("meep-connect-phase-CONNECT-COPY", 0, 0, 0, (swig_guile_proc) _wrap_meep_connect_phase_CONNECT_COPY);
  scm_c_define_gsubr("NUM-CONNECT-PHASE-TYPES", 0, 0, 0, (swig_guile_proc) _wrap_NUM_CONNECT_PHASE_TYPES);
  SWIG_TypeClientData(SWIGTYPE_p_meep__structure, (void *) &_swig_guile_clientdatameep_structure);
  scm_c_define_gsubr("meep-structure-chunks-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunks_set);
  scm_c_define_gsubr("meep-structure-chunks-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_chunks_get);
  scm_c_define_gsubr("meep-structure-num-chunks-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_num_chunks_set);
  scm_c_define_gsubr("meep-structure-num-chunks-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_num_chunks_get);
  scm_c_define_gsubr("meep-structure-shared-chunks-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_shared_chunks_set);
  scm_c_define_gsubr("meep-structure-shared-chunks-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_shared_chunks_get);
  scm_c_define_gsubr("meep-structure-gv-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_gv_set);
  scm_c_define_gsubr("meep-structure-gv-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_gv_get);
  scm_c_define_gsubr("meep-structure-user-volume-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_user_volume_set);
  scm_c_define_gsubr("meep-structure-user-volume-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_user_volume_get);
  scm_c_define_gsubr("meep-structure-a-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_a_set);
  scm_c_define_gsubr("meep-structure-a-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_a_get);
  scm_c_define_gsubr("meep-structure-Courant-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_Courant_set);
  scm_c_define_gsubr("meep-structure-Courant-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_Courant_get);
  scm_c_define_gsubr("meep-structure-dt-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_dt_set);
  scm_c_define_gsubr("meep-structure-dt-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_dt_get);
  scm_c_define_gsubr("meep-structure-v-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_v_set);
  scm_c_define_gsubr("meep-structure-v-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_v_get);
  scm_c_define_gsubr("meep-structure-S-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_S_set);
  scm_c_define_gsubr("meep-structure-S-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_S_get);
  scm_c_define_gsubr("meep-structure-outdir-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_outdir_set);
  scm_c_define_gsubr("meep-structure-outdir-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_outdir_get);
  scm_c_define_gsubr("meep-structure-effort-volumes-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_effort_volumes_set);
  scm_c_define_gsubr("meep-structure-effort-volumes-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_effort_volumes_get);
  scm_c_define_gsubr("meep-structure-effort-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_effort_set);
  scm_c_define_gsubr("meep-structure-effort-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_effort_get);
  scm_c_define_gsubr("meep-structure-num-effort-volumes-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_num_effort_volumes_set);
  scm_c_define_gsubr("meep-structure-num-effort-volumes-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_num_effort_volumes_get);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__structure->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_structure;
  scm_c_define_gsubr("delete-meep-structure", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_structure);
  scm_c_define_gsubr("new-meep-structure", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_structure);
  scm_c_define_gsubr("meep-structure-set-materials", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_set_materials);
  scm_c_define_gsubr("meep-structure-set-chi1inv", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_set_chi1inv);
  scm_c_define_gsubr("meep-structure-has-chi", 3, 0, 0, (swig_guile_proc) _wrap_meep_structure_has_chi);
  scm_c_define_gsubr("meep-structure-set-epsilon", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_set_epsilon);
  scm_c_define_gsubr("meep-structure-set-mu", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_set_mu);
  scm_c_define_gsubr("meep-structure-set-conductivity", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_set_conductivity);
  scm_c_define_gsubr("meep-structure-set-chi3", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_set_chi3);
  scm_c_define_gsubr("meep-structure-set-chi2", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_set_chi2);
  scm_c_define_gsubr("meep-structure-add-susceptibility", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_add_susceptibility);
  scm_c_define_gsubr("meep-structure-remove-susceptibilities", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_remove_susceptibilities);
  scm_c_define_gsubr("meep-structure-set-output-directory", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_set_output_directory);
  scm_c_define_gsubr("meep-structure-mix-with", 3, 0, 0, (swig_guile_proc) _wrap_meep_structure_mix_with);
  scm_c_define_gsubr("meep-structure-equal-layout", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_equal_layout);
  scm_c_define_gsubr("meep-structure-print-layout", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_print_layout);
  scm_c_define_gsubr("meep-structure-get-chunk-volumes", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_get_chunk_volumes);
  scm_c_define_gsubr("meep-structure-get-chunk-owners", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_get_chunk_owners);
  scm_c_define_gsubr("meep-structure-dump", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_dump);
  scm_c_define_gsubr("meep-structure-load", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_load);
  scm_c_define_gsubr("meep-structure-dump-chunk-layout", 2, 0, 0, (swig_guile_proc) _wrap_meep_structure_dump_chunk_layout);
  scm_c_define_gsubr("meep-structure-load-chunk-layout", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_load_chunk_layout);
  scm_c_define_gsubr("meep-structure-get-chi1inv", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_get_chi1inv);
  scm_c_define_gsubr("meep-structure-get-inveps", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_get_inveps);
  scm_c_define_gsubr("meep-structure-get-eps", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_get_eps);
  scm_c_define_gsubr("meep-structure-get-mu", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_get_mu);
  scm_c_define_gsubr("meep-structure-max-eps", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_max_eps);
  scm_c_define_gsubr("meep-structure-estimated-cost", 0, 0, 1, (swig_guile_proc) _wrap_meep_structure_estimated_cost);
  scm_c_define_gsubr("meep-structure-get-binary-partition", 1, 0, 0, (swig_guile_proc) _wrap_meep_structure_get_binary_partition);
  scm_c_define_gsubr("meep-split-by-binarytree", 4, 0, 0, (swig_guile_proc) _wrap_meep_split_by_binarytree);
  SWIG_TypeClientData(SWIGTYPE_p_meep__src_time, (void *) &_swig_guile_clientdatameep_src_time);
  scm_c_define_gsubr("meep-src-time-is-integrated-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_src_time_is_integrated_set);
  scm_c_define_gsubr("meep-src-time-is-integrated-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_src_time_is_integrated_get);
  scm_c_define_gsubr("meep-src-time-id-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_src_time_id_set);
  scm_c_define_gsubr("meep-src-time-id-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_src_time_id_get);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__src_time->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_src_time;
  scm_c_define_gsubr("delete-meep-src-time", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_src_time);
  scm_c_define_gsubr("new-meep-src-time", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_src_time);
  scm_c_define_gsubr("meep-src-time-update", 3, 0, 0, (swig_guile_proc) _wrap_meep_src_time_update);
  scm_c_define_gsubr("meep-src-time-current", 0, 0, 1, (swig_guile_proc) _wrap_meep_src_time_current);
  scm_c_define_gsubr("meep-src-time-last-time-max", 0, 0, 1, (swig_guile_proc) _wrap_meep_src_time_last_time_max);
  scm_c_define_gsubr("meep-src-time-add-to", 3, 0, 0, (swig_guile_proc) _wrap_meep_src_time_add_to);
  scm_c_define_gsubr("meep-src-time-next-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_src_time_next_set);
  scm_c_define_gsubr("meep-src-time-next-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_src_time_next_get);
  scm_c_define_gsubr("meep-src-time-dipole", 0, 0, 1, (swig_guile_proc) _wrap_meep_src_time_dipole);
  scm_c_define_gsubr("meep-src-time-last-time", 1, 0, 0, (swig_guile_proc) _wrap_meep_src_time_last_time);
  scm_c_define_gsubr("meep-src-time-clone", 1, 0, 0, (swig_guile_proc) _wrap_meep_src_time_clone);
  scm_c_define_gsubr("meep-src-time-is-equal", 2, 0, 0, (swig_guile_proc) _wrap_meep_src_time_is_equal);
  scm_c_define_gsubr("meep-src-time-frequency", 1, 0, 0, (swig_guile_proc) _wrap_meep_src_time_frequency);
  scm_c_define_gsubr("meep-src-time-get-fwidth", 1, 0, 0, (swig_guile_proc) _wrap_meep_src_time_get_fwidth);
  scm_c_define_gsubr("meep-src-time-set-fwidth", 2, 0, 0, (swig_guile_proc) _wrap_meep_src_time_set_fwidth);
  scm_c_define_gsubr("meep-src-time-set-frequency", 2, 0, 0, (swig_guile_proc) _wrap_meep_src_time_set_frequency);
  scm_c_define_gsubr("meep-src-times-equal", 2, 0, 0, (swig_guile_proc) _wrap_meep_src_times_equal);
  SWIG_TypeClientData(SWIGTYPE_p_meep__gaussian_src_time, (void *) &_swig_guile_clientdatameep_gaussian_src_time);
  scm_c_define_gsubr("new-meep-gaussian-src-time", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_gaussian_src_time);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__gaussian_src_time->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_gaussian_src_time;
  scm_c_define_gsubr("delete-meep-gaussian-src-time", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_gaussian_src_time);
  scm_c_define_gsubr("meep-gaussian-src-time-dipole", 2, 0, 0, (swig_guile_proc) _wrap_meep_gaussian_src_time_dipole);
  scm_c_define_gsubr("meep-gaussian-src-time-last-time", 1, 0, 0, (swig_guile_proc) _wrap_meep_gaussian_src_time_last_time);
  scm_c_define_gsubr("meep-gaussian-src-time-clone", 1, 0, 0, (swig_guile_proc) _wrap_meep_gaussian_src_time_clone);
  scm_c_define_gsubr("meep-gaussian-src-time-is-equal", 2, 0, 0, (swig_guile_proc) _wrap_meep_gaussian_src_time_is_equal);
  scm_c_define_gsubr("meep-gaussian-src-time-frequency", 1, 0, 0, (swig_guile_proc) _wrap_meep_gaussian_src_time_frequency);
  scm_c_define_gsubr("meep-gaussian-src-time-get-fwidth", 1, 0, 0, (swig_guile_proc) _wrap_meep_gaussian_src_time_get_fwidth);
  scm_c_define_gsubr("meep-gaussian-src-time-set-fwidth", 2, 0, 0, (swig_guile_proc) _wrap_meep_gaussian_src_time_set_fwidth);
  scm_c_define_gsubr("meep-gaussian-src-time-set-frequency", 2, 0, 0, (swig_guile_proc) _wrap_meep_gaussian_src_time_set_frequency);
  scm_c_define_gsubr("meep-gaussian-src-time-fourier-transform", 2, 0, 0, (swig_guile_proc) _wrap_meep_gaussian_src_time_fourier_transform);
  SWIG_TypeClientData(SWIGTYPE_p_meep__continuous_src_time, (void *) &_swig_guile_clientdatameep_continuous_src_time);
  scm_c_define_gsubr("new-meep-continuous-src-time", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_continuous_src_time);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__continuous_src_time->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_continuous_src_time;
  scm_c_define_gsubr("delete-meep-continuous-src-time", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_continuous_src_time);
  scm_c_define_gsubr("meep-continuous-src-time-dipole", 2, 0, 0, (swig_guile_proc) _wrap_meep_continuous_src_time_dipole);
  scm_c_define_gsubr("meep-continuous-src-time-last-time", 1, 0, 0, (swig_guile_proc) _wrap_meep_continuous_src_time_last_time);
  scm_c_define_gsubr("meep-continuous-src-time-clone", 1, 0, 0, (swig_guile_proc) _wrap_meep_continuous_src_time_clone);
  scm_c_define_gsubr("meep-continuous-src-time-is-equal", 2, 0, 0, (swig_guile_proc) _wrap_meep_continuous_src_time_is_equal);
  scm_c_define_gsubr("meep-continuous-src-time-frequency", 1, 0, 0, (swig_guile_proc) _wrap_meep_continuous_src_time_frequency);
  scm_c_define_gsubr("meep-continuous-src-time-get-fwidth", 1, 0, 0, (swig_guile_proc) _wrap_meep_continuous_src_time_get_fwidth);
  scm_c_define_gsubr("meep-continuous-src-time-set-frequency", 2, 0, 0, (swig_guile_proc) _wrap_meep_continuous_src_time_set_frequency);
  SWIG_TypeClientData(SWIGTYPE_p_meep__custom_src_time, (void *) &_swig_guile_clientdatameep_custom_src_time);
  scm_c_define_gsubr("new-meep-custom-src-time", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_custom_src_time);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__custom_src_time->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_custom_src_time;
  scm_c_define_gsubr("delete-meep-custom-src-time", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_custom_src_time);
  scm_c_define_gsubr("meep-custom-src-time-current", 3, 0, 0, (swig_guile_proc) _wrap_meep_custom_src_time_current);
  scm_c_define_gsubr("meep-custom-src-time-dipole", 2, 0, 0, (swig_guile_proc) _wrap_meep_custom_src_time_dipole);
  scm_c_define_gsubr("meep-custom-src-time-last-time", 1, 0, 0, (swig_guile_proc) _wrap_meep_custom_src_time_last_time);
  scm_c_define_gsubr("meep-custom-src-time-clone", 1, 0, 0, (swig_guile_proc) _wrap_meep_custom_src_time_clone);
  scm_c_define_gsubr("meep-custom-src-time-is-equal", 2, 0, 0, (swig_guile_proc) _wrap_meep_custom_src_time_is_equal);
  scm_c_define_gsubr("meep-custom-src-time-frequency", 1, 0, 0, (swig_guile_proc) _wrap_meep_custom_src_time_frequency);
  scm_c_define_gsubr("meep-custom-src-time-set-frequency", 2, 0, 0, (swig_guile_proc) _wrap_meep_custom_src_time_set_frequency);
  scm_c_define_gsubr("meep-custom-src-time-get-fwidth", 1, 0, 0, (swig_guile_proc) _wrap_meep_custom_src_time_get_fwidth);
  scm_c_define_gsubr("meep-custom-src-time-set-fwidth", 2, 0, 0, (swig_guile_proc) _wrap_meep_custom_src_time_set_fwidth);
  SWIG_TypeClientData(SWIGTYPE_p_meep__monitor_point, (void *) &_swig_guile_clientdatameep_monitor_point);
  scm_c_define_gsubr("new-meep-monitor-point", 0, 0, 0, (swig_guile_proc) _wrap_new_meep_monitor_point);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__monitor_point->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_monitor_point;
  scm_c_define_gsubr("delete-meep-monitor-point", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_monitor_point);
  scm_c_define_gsubr("meep-monitor-point-loc-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_monitor_point_loc_set);
  scm_c_define_gsubr("meep-monitor-point-loc-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_monitor_point_loc_get);
  scm_c_define_gsubr("meep-monitor-point-t-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_monitor_point_t_set);
  scm_c_define_gsubr("meep-monitor-point-t-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_monitor_point_t_get);
  scm_c_define_gsubr("meep-monitor-point-f-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_monitor_point_f_set);
  scm_c_define_gsubr("meep-monitor-point-f-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_monitor_point_f_get);
  scm_c_define_gsubr("meep-monitor-point-next-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_monitor_point_next_set);
  scm_c_define_gsubr("meep-monitor-point-next-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_monitor_point_next_get);
  scm_c_define_gsubr("meep-monitor-point-get-component", 2, 0, 0, (swig_guile_proc) _wrap_meep_monitor_point_get_component);
  scm_c_define_gsubr("meep-monitor-point-poynting-in-direction", 0, 0, 1, (swig_guile_proc) _wrap_meep_monitor_point_poynting_in_direction);
  scm_c_define_gsubr("meep-monitor-point-fourier-transform", 0, 0, 1, (swig_guile_proc) _wrap_meep_monitor_point_fourier_transform);
  scm_c_define_gsubr("meep-monitor-point-harminv", 8, 0, 0, (swig_guile_proc) _wrap_meep_monitor_point_harminv);
  SWIG_TypeClientData(SWIGTYPE_p_meep__dft_chunk, (void *) &_swig_guile_clientdatameep_dft_chunk);
  scm_c_define_gsubr("new-meep-dft-chunk", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_dft_chunk_rest);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__dft_chunk->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_dft_chunk;
  scm_c_define_gsubr("delete-meep-dft-chunk", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_dft_chunk);
  scm_c_define_gsubr("meep-dft-chunk-update-dft", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_update_dft);
  scm_c_define_gsubr("meep-dft-chunk-norm2", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_norm2);
  scm_c_define_gsubr("meep-dft-chunk-maxomega", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_maxomega);
  scm_c_define_gsubr("meep-dft-chunk-scale-dft", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_scale_dft);
  scm_c_define_gsubr("meep-dft-chunk-process-dft-component", 0, 0, 1, (swig_guile_proc) _wrap_meep_dft_chunk_process_dft_component_rest);
  scm_c_define_gsubr("meep-dft-chunk-get-decimation-factor", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_get_decimation_factor);
  scm_c_define_gsubr("meep-dft-chunk-meep-dft-chunk-subeq", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_meep_dft_chunk_subeq);
  scm_c_define_gsubr("meep-dft-chunk-omega-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_omega_set);
  scm_c_define_gsubr("meep-dft-chunk-omega-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_omega_get);
  scm_c_define_gsubr("meep-dft-chunk-persist-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_persist_set);
  scm_c_define_gsubr("meep-dft-chunk-persist-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_persist_get);
  scm_c_define_gsubr("meep-dft-chunk-c-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_c_set);
  scm_c_define_gsubr("meep-dft-chunk-c-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_c_get);
  scm_c_define_gsubr("meep-dft-chunk-N-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_N_set);
  scm_c_define_gsubr("meep-dft-chunk-N-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_N_get);
  scm_c_define_gsubr("meep-dft-chunk-dft-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_dft_set);
  scm_c_define_gsubr("meep-dft-chunk-dft-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_dft_get);
  scm_c_define_gsubr("meep-dft-chunk-next-in-chunk-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_next_in_chunk_set);
  scm_c_define_gsubr("meep-dft-chunk-next-in-chunk-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_next_in_chunk_get);
  scm_c_define_gsubr("meep-dft-chunk-next-in-dft-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_next_in_dft_set);
  scm_c_define_gsubr("meep-dft-chunk-next-in-dft-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_next_in_dft_get);
  scm_c_define_gsubr("meep-dft-chunk-stored-weight-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_stored_weight_set);
  scm_c_define_gsubr("meep-dft-chunk-stored-weight-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_stored_weight_get);
  scm_c_define_gsubr("meep-dft-chunk-include-dV-and-interp-weights-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_include_dV_and_interp_weights_set);
  scm_c_define_gsubr("meep-dft-chunk-include-dV-and-interp-weights-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_include_dV_and_interp_weights_get);
  scm_c_define_gsubr("meep-dft-chunk-sqrt-dV-and-interp-weights-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_sqrt_dV_and_interp_weights_set);
  scm_c_define_gsubr("meep-dft-chunk-sqrt-dV-and-interp-weights-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_sqrt_dV_and_interp_weights_get);
  scm_c_define_gsubr("meep-dft-chunk-extra-weight-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_extra_weight_set);
  scm_c_define_gsubr("meep-dft-chunk-extra-weight-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_extra_weight_get);
  scm_c_define_gsubr("meep-dft-chunk-fc-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_fc_set);
  scm_c_define_gsubr("meep-dft-chunk-fc-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_fc_get);
  scm_c_define_gsubr("meep-dft-chunk-is-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_is_set);
  scm_c_define_gsubr("meep-dft-chunk-is-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_is_get);
  scm_c_define_gsubr("meep-dft-chunk-ie-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_ie_set);
  scm_c_define_gsubr("meep-dft-chunk-ie-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_ie_get);
  scm_c_define_gsubr("meep-dft-chunk-is-old-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_is_old_set);
  scm_c_define_gsubr("meep-dft-chunk-is-old-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_is_old_get);
  scm_c_define_gsubr("meep-dft-chunk-ie-old-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_ie_old_set);
  scm_c_define_gsubr("meep-dft-chunk-ie-old-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_ie_old_get);
  scm_c_define_gsubr("meep-dft-chunk-s0-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_s0_set);
  scm_c_define_gsubr("meep-dft-chunk-s0-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_s0_get);
  scm_c_define_gsubr("meep-dft-chunk-s1-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_s1_set);
  scm_c_define_gsubr("meep-dft-chunk-s1-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_s1_get);
  scm_c_define_gsubr("meep-dft-chunk-e0-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_e0_set);
  scm_c_define_gsubr("meep-dft-chunk-e0-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_e0_get);
  scm_c_define_gsubr("meep-dft-chunk-e1-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_e1_set);
  scm_c_define_gsubr("meep-dft-chunk-e1-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_e1_get);
  scm_c_define_gsubr("meep-dft-chunk-dV0-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_dV0_set);
  scm_c_define_gsubr("meep-dft-chunk-dV0-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_dV0_get);
  scm_c_define_gsubr("meep-dft-chunk-dV1-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_dV1_set);
  scm_c_define_gsubr("meep-dft-chunk-dV1-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_dV1_get);
  scm_c_define_gsubr("meep-dft-chunk-empty-dim-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_empty_dim_set);
  scm_c_define_gsubr("meep-dft-chunk-empty-dim-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_empty_dim_get);
  scm_c_define_gsubr("meep-dft-chunk-scale-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_scale_set);
  scm_c_define_gsubr("meep-dft-chunk-scale-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_scale_get);
  scm_c_define_gsubr("meep-dft-chunk-shift-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_shift_set);
  scm_c_define_gsubr("meep-dft-chunk-shift-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_shift_get);
  scm_c_define_gsubr("meep-dft-chunk-S-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_S_set);
  scm_c_define_gsubr("meep-dft-chunk-S-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_S_get);
  scm_c_define_gsubr("meep-dft-chunk-sn-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_sn_set);
  scm_c_define_gsubr("meep-dft-chunk-sn-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_sn_get);
  scm_c_define_gsubr("meep-dft-chunk-dft-phase-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_dft_phase_set);
  scm_c_define_gsubr("meep-dft-chunk-dft-phase-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_dft_phase_get);
  scm_c_define_gsubr("meep-dft-chunk-avg1-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_avg1_set);
  scm_c_define_gsubr("meep-dft-chunk-avg1-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_avg1_get);
  scm_c_define_gsubr("meep-dft-chunk-avg2-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_avg2_set);
  scm_c_define_gsubr("meep-dft-chunk-avg2-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_avg2_get);
  scm_c_define_gsubr("meep-dft-chunk-vc-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_vc_set);
  scm_c_define_gsubr("meep-dft-chunk-vc-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_chunk_vc_get);
  scm_c_define_gsubr("meep-save-dft-hdf5", 0, 0, 1, (swig_guile_proc) _wrap_meep_save_dft_hdf5);
  scm_c_define_gsubr("meep-load-dft-hdf5", 0, 0, 1, (swig_guile_proc) _wrap_meep_load_dft_hdf5);
  SWIG_TypeClientData(SWIGTYPE_p_meep__dft_flux, (void *) &_swig_guile_clientdatameep_dft_flux);
  scm_c_define_gsubr("new-meep-dft-flux", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_dft_flux);
  scm_c_define_gsubr("meep-dft-flux-flux", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_flux);
  scm_c_define_gsubr("meep-dft-flux-meep-dft-flux-subeq", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_meep_dft_flux_subeq);
  scm_c_define_gsubr("meep-dft-flux-save-hdf5", 0, 0, 1, (swig_guile_proc) _wrap_meep_dft_flux_save_hdf5);
  scm_c_define_gsubr("meep-dft-flux-load-hdf5", 0, 0, 1, (swig_guile_proc) _wrap_meep_dft_flux_load_hdf5);
  scm_c_define_gsubr("meep-dft-flux-scale-dfts", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_scale_dfts);
  scm_c_define_gsubr("meep-dft-flux-remove", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_remove);
  scm_c_define_gsubr("meep-dft-flux-freq-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_freq_set);
  scm_c_define_gsubr("meep-dft-flux-freq-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_freq_get);
  scm_c_define_gsubr("meep-dft-flux-E-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_E_set);
  scm_c_define_gsubr("meep-dft-flux-E-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_E_get);
  scm_c_define_gsubr("meep-dft-flux-H-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_H_set);
  scm_c_define_gsubr("meep-dft-flux-H-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_H_get);
  scm_c_define_gsubr("meep-dft-flux-cE-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_cE_set);
  scm_c_define_gsubr("meep-dft-flux-cE-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_cE_get);
  scm_c_define_gsubr("meep-dft-flux-cH-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_cH_set);
  scm_c_define_gsubr("meep-dft-flux-cH-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_cH_get);
  scm_c_define_gsubr("meep-dft-flux-where-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_where_set);
  scm_c_define_gsubr("meep-dft-flux-where-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_where_get);
  scm_c_define_gsubr("meep-dft-flux-normal-direction-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_normal_direction_set);
  scm_c_define_gsubr("meep-dft-flux-normal-direction-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_normal_direction_get);
  scm_c_define_gsubr("meep-dft-flux-use-symmetry-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_use_symmetry_set);
  scm_c_define_gsubr("meep-dft-flux-use-symmetry-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_flux_use_symmetry_get);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__dft_flux->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_dft_flux;
  scm_c_define_gsubr("delete-meep-dft-flux", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_dft_flux);
  SWIG_TypeClientData(SWIGTYPE_p_meep__dft_energy, (void *) &_swig_guile_clientdatameep_dft_energy);
  scm_c_define_gsubr("new-meep-dft-energy", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_dft_energy);
  scm_c_define_gsubr("meep-dft-energy-electric", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_electric);
  scm_c_define_gsubr("meep-dft-energy-magnetic", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_magnetic);
  scm_c_define_gsubr("meep-dft-energy-total", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_total);
  scm_c_define_gsubr("meep-dft-energy-save-hdf5", 0, 0, 1, (swig_guile_proc) _wrap_meep_dft_energy_save_hdf5);
  scm_c_define_gsubr("meep-dft-energy-load-hdf5", 0, 0, 1, (swig_guile_proc) _wrap_meep_dft_energy_load_hdf5);
  scm_c_define_gsubr("meep-dft-energy-scale-dfts", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_scale_dfts);
  scm_c_define_gsubr("meep-dft-energy-remove", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_remove);
  scm_c_define_gsubr("meep-dft-energy-freq-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_freq_set);
  scm_c_define_gsubr("meep-dft-energy-freq-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_freq_get);
  scm_c_define_gsubr("meep-dft-energy-E-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_E_set);
  scm_c_define_gsubr("meep-dft-energy-E-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_E_get);
  scm_c_define_gsubr("meep-dft-energy-H-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_H_set);
  scm_c_define_gsubr("meep-dft-energy-H-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_H_get);
  scm_c_define_gsubr("meep-dft-energy-D-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_D_set);
  scm_c_define_gsubr("meep-dft-energy-D-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_D_get);
  scm_c_define_gsubr("meep-dft-energy-B-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_B_set);
  scm_c_define_gsubr("meep-dft-energy-B-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_B_get);
  scm_c_define_gsubr("meep-dft-energy-where-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_where_set);
  scm_c_define_gsubr("meep-dft-energy-where-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_energy_where_get);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__dft_energy->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_dft_energy;
  scm_c_define_gsubr("delete-meep-dft-energy", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_dft_energy);
  SWIG_TypeClientData(SWIGTYPE_p_meep__dft_force, (void *) &_swig_guile_clientdatameep_dft_force);
  scm_c_define_gsubr("new-meep-dft-force", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_dft_force);
  scm_c_define_gsubr("meep-dft-force-force", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_force_force);
  scm_c_define_gsubr("meep-dft-force-save-hdf5", 0, 0, 1, (swig_guile_proc) _wrap_meep_dft_force_save_hdf5);
  scm_c_define_gsubr("meep-dft-force-load-hdf5", 0, 0, 1, (swig_guile_proc) _wrap_meep_dft_force_load_hdf5);
  scm_c_define_gsubr("meep-dft-force-scale-dfts", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_force_scale_dfts);
  scm_c_define_gsubr("meep-dft-force-remove", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_force_remove);
  scm_c_define_gsubr("meep-dft-force-freq-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_force_freq_set);
  scm_c_define_gsubr("meep-dft-force-freq-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_force_freq_get);
  scm_c_define_gsubr("meep-dft-force-offdiag1-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_force_offdiag1_set);
  scm_c_define_gsubr("meep-dft-force-offdiag1-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_force_offdiag1_get);
  scm_c_define_gsubr("meep-dft-force-offdiag2-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_force_offdiag2_set);
  scm_c_define_gsubr("meep-dft-force-offdiag2-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_force_offdiag2_get);
  scm_c_define_gsubr("meep-dft-force-diag-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_force_diag_set);
  scm_c_define_gsubr("meep-dft-force-diag-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_force_diag_get);
  scm_c_define_gsubr("meep-dft-force-where-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_force_where_set);
  scm_c_define_gsubr("meep-dft-force-where-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_force_where_get);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__dft_force->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_dft_force;
  scm_c_define_gsubr("delete-meep-dft-force", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_dft_force);
  SWIG_TypeClientData(SWIGTYPE_p_meep__sourcedata, (void *) &_swig_guile_clientdatasourcedata);
  scm_c_define_gsubr("sourcedata-near-fd-comp-set", 2, 0, 0, (swig_guile_proc) _wrap_sourcedata_near_fd_comp_set);
  scm_c_define_gsubr("sourcedata-near-fd-comp-get", 1, 0, 0, (swig_guile_proc) _wrap_sourcedata_near_fd_comp_get);
  scm_c_define_gsubr("sourcedata-idx-arr-set", 2, 0, 0, (swig_guile_proc) _wrap_sourcedata_idx_arr_set);
  scm_c_define_gsubr("sourcedata-idx-arr-get", 1, 0, 0, (swig_guile_proc) _wrap_sourcedata_idx_arr_get);
  scm_c_define_gsubr("sourcedata-fc-idx-set", 2, 0, 0, (swig_guile_proc) _wrap_sourcedata_fc_idx_set);
  scm_c_define_gsubr("sourcedata-fc-idx-get", 1, 0, 0, (swig_guile_proc) _wrap_sourcedata_fc_idx_get);
  scm_c_define_gsubr("sourcedata-amp-arr-set", 2, 0, 0, (swig_guile_proc) _wrap_sourcedata_amp_arr_set);
  scm_c_define_gsubr("sourcedata-amp-arr-get", 1, 0, 0, (swig_guile_proc) _wrap_sourcedata_amp_arr_get);
  scm_c_define_gsubr("new-sourcedata", 0, 0, 0, (swig_guile_proc) _wrap_new_sourcedata);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__sourcedata->clientdata))->destroy = (guile_destructor) _wrap_delete_sourcedata;
  scm_c_define_gsubr("delete-sourcedata", 1, 0, 0, (swig_guile_proc) _wrap_delete_sourcedata);
  SWIG_TypeClientData(SWIGTYPE_p_meep__dft_near2far, (void *) &_swig_guile_clientdatameep_dft_near2far);
  scm_c_define_gsubr("new-meep-dft-near2far", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_dft_near2far);
  scm_c_define_gsubr("meep-dft-near2far-farfield", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_farfield);
  scm_c_define_gsubr("meep-dft-near2far-farfield-lowlevel", 3, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_farfield_lowlevel);
  scm_c_define_gsubr("meep-dft-near2far-get-farfields-array", 6, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_get_farfields_array);
  scm_c_define_gsubr("meep-dft-near2far-save-farfields", 5, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_save_farfields);
  scm_c_define_gsubr("meep-dft-near2far-flux", 4, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_flux);
  scm_c_define_gsubr("meep-dft-near2far-save-hdf5", 0, 0, 1, (swig_guile_proc) _wrap_meep_dft_near2far_save_hdf5);
  scm_c_define_gsubr("meep-dft-near2far-load-hdf5", 0, 0, 1, (swig_guile_proc) _wrap_meep_dft_near2far_load_hdf5);
  scm_c_define_gsubr("meep-dft-near2far-scale-dfts", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_scale_dfts);
  scm_c_define_gsubr("meep-dft-near2far-remove", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_remove);
  scm_c_define_gsubr("meep-dft-near2far-freq-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_freq_set);
  scm_c_define_gsubr("meep-dft-near2far-freq-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_freq_get);
  scm_c_define_gsubr("meep-dft-near2far-F-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_F_set);
  scm_c_define_gsubr("meep-dft-near2far-F-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_F_get);
  scm_c_define_gsubr("meep-dft-near2far-eps-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_eps_set);
  scm_c_define_gsubr("meep-dft-near2far-eps-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_eps_get);
  scm_c_define_gsubr("meep-dft-near2far-mu-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_mu_set);
  scm_c_define_gsubr("meep-dft-near2far-mu-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_mu_get);
  scm_c_define_gsubr("meep-dft-near2far-where-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_where_set);
  scm_c_define_gsubr("meep-dft-near2far-where-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_where_get);
  scm_c_define_gsubr("meep-dft-near2far-periodic-d-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_periodic_d_set);
  scm_c_define_gsubr("meep-dft-near2far-periodic-d-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_periodic_d_get);
  scm_c_define_gsubr("meep-dft-near2far-periodic-n-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_periodic_n_set);
  scm_c_define_gsubr("meep-dft-near2far-periodic-n-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_periodic_n_get);
  scm_c_define_gsubr("meep-dft-near2far-periodic-k-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_periodic_k_set);
  scm_c_define_gsubr("meep-dft-near2far-periodic-k-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_periodic_k_get);
  scm_c_define_gsubr("meep-dft-near2far-period-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_period_set);
  scm_c_define_gsubr("meep-dft-near2far-period-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_period_get);
  scm_c_define_gsubr("meep-dft-near2far-near-sourcedata", 5, 0, 0, (swig_guile_proc) _wrap_meep_dft_near2far_near_sourcedata);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__dft_near2far->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_dft_near2far;
  scm_c_define_gsubr("delete-meep-dft-near2far", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_dft_near2far);
  SWIG_TypeClientData(SWIGTYPE_p_meep__dft_ldos, (void *) &_swig_guile_clientdatameep_dft_ldos);
  scm_c_define_gsubr("new-meep-dft-ldos", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_dft_ldos);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__dft_ldos->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_dft_ldos;
  scm_c_define_gsubr("delete-meep-dft-ldos", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_dft_ldos);
  scm_c_define_gsubr("meep-dft-ldos-update", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_ldos_update);
  scm_c_define_gsubr("meep-dft-ldos-ldos", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_ldos_ldos);
  scm_c_define_gsubr("meep-dft-ldos-F", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_ldos_F);
  scm_c_define_gsubr("meep-dft-ldos-J", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_ldos_J);
  scm_c_define_gsubr("meep-dft-ldos-freq-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_ldos_freq_set);
  scm_c_define_gsubr("meep-dft-ldos-freq-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_ldos_freq_get);
  scm_c_define_gsubr("meep-dft-ldos-overall-scale", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_ldos_overall_scale);
  SWIG_TypeClientData(SWIGTYPE_p_meep__dft_fields, (void *) &_swig_guile_clientdatameep_dft_fields);
  scm_c_define_gsubr("new-meep-dft-fields", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_dft_fields);
  scm_c_define_gsubr("meep-dft-fields-fourier-sourcedata", 5, 0, 0, (swig_guile_proc) _wrap_meep_dft_fields_fourier_sourcedata);
  scm_c_define_gsubr("meep-dft-fields-scale-dfts", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_fields_scale_dfts);
  scm_c_define_gsubr("meep-dft-fields-remove", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_fields_remove);
  scm_c_define_gsubr("meep-dft-fields-freq-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_fields_freq_set);
  scm_c_define_gsubr("meep-dft-fields-freq-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_fields_freq_get);
  scm_c_define_gsubr("meep-dft-fields-chunks-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_fields_chunks_set);
  scm_c_define_gsubr("meep-dft-fields-chunks-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_fields_chunks_get);
  scm_c_define_gsubr("meep-dft-fields-where-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_dft_fields_where_set);
  scm_c_define_gsubr("meep-dft-fields-where-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_dft_fields_where_get);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__dft_fields->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_dft_fields;
  scm_c_define_gsubr("delete-meep-dft-fields", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_dft_fields);
  SWIG_TypeClientData(SWIGTYPE_p_meep__polarization_state_s, (void *) &_swig_guile_clientdatapolarization_state);
  scm_c_define_gsubr("polarization-state-data-set", 2, 0, 0, (swig_guile_proc) _wrap_polarization_state_data_set);
  scm_c_define_gsubr("polarization-state-data-get", 1, 0, 0, (swig_guile_proc) _wrap_polarization_state_data_get);
  scm_c_define_gsubr("polarization-state-s-set", 2, 0, 0, (swig_guile_proc) _wrap_polarization_state_s_set);
  scm_c_define_gsubr("polarization-state-s-get", 1, 0, 0, (swig_guile_proc) _wrap_polarization_state_s_get);
  scm_c_define_gsubr("polarization-state-next-set", 2, 0, 0, (swig_guile_proc) _wrap_polarization_state_next_set);
  scm_c_define_gsubr("polarization-state-next-get", 1, 0, 0, (swig_guile_proc) _wrap_polarization_state_next_get);
  scm_c_define_gsubr("new-polarization-state", 0, 0, 0, (swig_guile_proc) _wrap_new_polarization_state);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__polarization_state_s->clientdata))->destroy = (guile_destructor) _wrap_delete_polarization_state;
  scm_c_define_gsubr("delete-polarization-state", 1, 0, 0, (swig_guile_proc) _wrap_delete_polarization_state);
  scm_c_define_gsubr("meep-boundary-condition-Periodic", 0, 0, 0, (swig_guile_proc) _wrap_meep_boundary_condition_Periodic);
  scm_c_define_gsubr("meep-boundary-condition-Metallic", 0, 0, 0, (swig_guile_proc) _wrap_meep_boundary_condition_Metallic);
  scm_c_define_gsubr("meep-boundary-condition-Magnetic", 0, 0, 0, (swig_guile_proc) _wrap_meep_boundary_condition_Magnetic);
  scm_c_define_gsubr("meep-boundary-condition-None", 0, 0, 0, (swig_guile_proc) _wrap_meep_boundary_condition_None);
  scm_c_define_gsubr("meep-time-sink-Connecting", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_Connecting);
  scm_c_define_gsubr("meep-time-sink-Stepping", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_Stepping);
  scm_c_define_gsubr("meep-time-sink-Boundaries", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_Boundaries);
  scm_c_define_gsubr("meep-time-sink-MpiAllTime", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_MpiAllTime);
  scm_c_define_gsubr("meep-time-sink-MpiOneTime", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_MpiOneTime);
  scm_c_define_gsubr("meep-time-sink-FieldOutput", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_FieldOutput);
  scm_c_define_gsubr("meep-time-sink-FourierTransforming", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_FourierTransforming);
  scm_c_define_gsubr("meep-time-sink-MPBTime", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_MPBTime);
  scm_c_define_gsubr("meep-time-sink-GetFarfieldsTime", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_GetFarfieldsTime);
  scm_c_define_gsubr("meep-time-sink-Other", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_Other);
  scm_c_define_gsubr("meep-time-sink-FieldUpdateB", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_FieldUpdateB);
  scm_c_define_gsubr("meep-time-sink-FieldUpdateH", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_FieldUpdateH);
  scm_c_define_gsubr("meep-time-sink-FieldUpdateD", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_FieldUpdateD);
  scm_c_define_gsubr("meep-time-sink-FieldUpdateE", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_FieldUpdateE);
  scm_c_define_gsubr("meep-time-sink-BoundarySteppingB", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_BoundarySteppingB);
  scm_c_define_gsubr("meep-time-sink-BoundarySteppingWH", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_BoundarySteppingWH);
  scm_c_define_gsubr("meep-time-sink-BoundarySteppingPH", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_BoundarySteppingPH);
  scm_c_define_gsubr("meep-time-sink-BoundarySteppingH", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_BoundarySteppingH);
  scm_c_define_gsubr("meep-time-sink-BoundarySteppingD", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_BoundarySteppingD);
  scm_c_define_gsubr("meep-time-sink-BoundarySteppingWE", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_BoundarySteppingWE);
  scm_c_define_gsubr("meep-time-sink-BoundarySteppingPE", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_BoundarySteppingPE);
  scm_c_define_gsubr("meep-time-sink-BoundarySteppingE", 0, 0, 0, (swig_guile_proc) _wrap_meep_time_sink_BoundarySteppingE);
  SWIG_TypeClientData(SWIGTYPE_p_meep__timing_scope, (void *) &_swig_guile_clientdatatiming_scope);
  scm_c_define_gsubr("new-timing-scope", 0, 0, 1, (swig_guile_proc) _wrap_new_timing_scope);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__timing_scope->clientdata))->destroy = (guile_destructor) _wrap_delete_timing_scope;
  scm_c_define_gsubr("delete-timing-scope", 1, 0, 0, (swig_guile_proc) _wrap_delete_timing_scope);
  scm_c_define_gsubr("timing-scope-exit", 1, 0, 0, (swig_guile_proc) _wrap_timing_scope_exit);
  scm_c_define_gsubr("meep-derived-component-func", 4, 0, 0, (swig_guile_proc) _wrap_meep_derived_component_func);
  SWIG_TypeClientData(SWIGTYPE_p_meep__chunkloop_field_components, (void *) &_swig_guile_clientdatameep_chunkloop_field_components);
  scm_c_define_gsubr("new-meep-chunkloop-field-components", 7, 0, 0, (swig_guile_proc) _wrap_new_meep_chunkloop_field_components);
  scm_c_define_gsubr("meep-chunkloop-field-components-update-values", 2, 0, 0, (swig_guile_proc) _wrap_meep_chunkloop_field_components_update_values);
  scm_c_define_gsubr("meep-chunkloop-field-components-values-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_chunkloop_field_components_values_set);
  scm_c_define_gsubr("meep-chunkloop-field-components-values-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_chunkloop_field_components_values_get);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__chunkloop_field_components->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_chunkloop_field_components;
  scm_c_define_gsubr("delete-meep-chunkloop-field-components", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_chunkloop_field_components);
  SWIG_TypeClientData(SWIGTYPE_p_meep__diffractedplanewave, (void *) &_swig_guile_clientdatameep_diffractedplanewave);
  scm_c_define_gsubr("new-meep-diffractedplanewave", 4, 0, 0, (swig_guile_proc) _wrap_new_meep_diffractedplanewave);
  scm_c_define_gsubr("meep-diffractedplanewave-get-g", 1, 0, 0, (swig_guile_proc) _wrap_meep_diffractedplanewave_get_g);
  scm_c_define_gsubr("meep-diffractedplanewave-get-axis", 1, 0, 0, (swig_guile_proc) _wrap_meep_diffractedplanewave_get_axis);
  scm_c_define_gsubr("meep-diffractedplanewave-get-s", 1, 0, 0, (swig_guile_proc) _wrap_meep_diffractedplanewave_get_s);
  scm_c_define_gsubr("meep-diffractedplanewave-get-p", 1, 0, 0, (swig_guile_proc) _wrap_meep_diffractedplanewave_get_p);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__diffractedplanewave->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_diffractedplanewave;
  scm_c_define_gsubr("delete-meep-diffractedplanewave", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_diffractedplanewave);
  SWIG_TypeClientData(SWIGTYPE_p_meep__gaussianbeam, (void *) &_swig_guile_clientdatameep_gaussianbeam);
  scm_c_define_gsubr("new-meep-gaussianbeam", 7, 0, 0, (swig_guile_proc) _wrap_new_meep_gaussianbeam);
  scm_c_define_gsubr("meep-gaussianbeam-get-fields", 3, 0, 0, (swig_guile_proc) _wrap_meep_gaussianbeam_get_fields);
  scm_c_define_gsubr("meep-gaussianbeam-get-E0", 2, 0, 0, (swig_guile_proc) _wrap_meep_gaussianbeam_get_E0);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__gaussianbeam->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_gaussianbeam;
  scm_c_define_gsubr("delete-meep-gaussianbeam", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_gaussianbeam);
  SWIG_TypeClientData(SWIGTYPE_p_meep__fields, (void *) &_swig_guile_clientdatameep_fields);
  scm_c_define_gsubr("meep-fields-num-chunks-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_num_chunks_set);
  scm_c_define_gsubr("meep-fields-num-chunks-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_num_chunks_get);
  scm_c_define_gsubr("meep-fields-shared-chunks-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_shared_chunks_set);
  scm_c_define_gsubr("meep-fields-shared-chunks-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_shared_chunks_get);
  scm_c_define_gsubr("meep-fields-chunks-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_chunks_set);
  scm_c_define_gsubr("meep-fields-chunks-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_chunks_get);
  scm_c_define_gsubr("meep-fields-sources-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_sources_set);
  scm_c_define_gsubr("meep-fields-sources-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_sources_get);
  scm_c_define_gsubr("meep-fields-fluxes-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_fluxes_set);
  scm_c_define_gsubr("meep-fields-fluxes-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_fluxes_get);
  scm_c_define_gsubr("meep-fields-S-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_S_set);
  scm_c_define_gsubr("meep-fields-S-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_S_get);
  scm_c_define_gsubr("meep-fields-a-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_a_set);
  scm_c_define_gsubr("meep-fields-a-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_a_get);
  scm_c_define_gsubr("meep-fields-dt-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_dt_set);
  scm_c_define_gsubr("meep-fields-dt-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_dt_get);
  scm_c_define_gsubr("meep-fields-gv-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_gv_set);
  scm_c_define_gsubr("meep-fields-gv-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_gv_get);
  scm_c_define_gsubr("meep-fields-user-volume-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_user_volume_set);
  scm_c_define_gsubr("meep-fields-user-volume-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_user_volume_get);
  scm_c_define_gsubr("meep-fields-v-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_v_set);
  scm_c_define_gsubr("meep-fields-v-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_v_get);
  scm_c_define_gsubr("meep-fields-m-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_m_set);
  scm_c_define_gsubr("meep-fields-m-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_m_get);
  scm_c_define_gsubr("meep-fields-beta-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_beta_set);
  scm_c_define_gsubr("meep-fields-beta-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_beta_get);
  scm_c_define_gsubr("meep-fields-t-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_t_set);
  scm_c_define_gsubr("meep-fields-t-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_t_get);
  scm_c_define_gsubr("meep-fields-phasein-time-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_phasein_time_set);
  scm_c_define_gsubr("meep-fields-phasein-time-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_phasein_time_get);
  scm_c_define_gsubr("meep-fields-is-real-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_is_real_set);
  scm_c_define_gsubr("meep-fields-is-real-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_is_real_get);
  scm_c_define_gsubr("meep-fields-k-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_k_set);
  scm_c_define_gsubr("meep-fields-k-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_k_get);
  scm_c_define_gsubr("meep-fields-eikna-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_eikna_set);
  scm_c_define_gsubr("meep-fields-eikna-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_eikna_get);
  scm_c_define_gsubr("meep-fields-coskna-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_coskna_set);
  scm_c_define_gsubr("meep-fields-coskna-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_coskna_get);
  scm_c_define_gsubr("meep-fields-sinkna-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_sinkna_set);
  scm_c_define_gsubr("meep-fields-sinkna-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_sinkna_get);
  scm_c_define_gsubr("meep-fields-boundaries-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_boundaries_set);
  scm_c_define_gsubr("meep-fields-boundaries-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_boundaries_get);
  scm_c_define_gsubr("meep-fields-outdir-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_outdir_set);
  scm_c_define_gsubr("meep-fields-outdir-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_outdir_get);
  scm_c_define_gsubr("meep-fields-components-allocated-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_components_allocated_set);
  scm_c_define_gsubr("meep-fields-components-allocated-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_components_allocated_get);
  scm_c_define_gsubr("meep-fields-loop-tile-base-db-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_loop_tile_base_db_set);
  scm_c_define_gsubr("meep-fields-loop-tile-base-db-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_loop_tile_base_db_get);
  scm_c_define_gsubr("meep-fields-loop-tile-base-eh-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_loop_tile_base_eh_set);
  scm_c_define_gsubr("meep-fields-loop-tile-base-eh-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_loop_tile_base_eh_get);
  scm_c_define_gsubr("new-meep-fields", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_fields);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__fields->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_fields;
  scm_c_define_gsubr("delete-meep-fields", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_fields);
  scm_c_define_gsubr("meep-fields-equal-layout", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_equal_layout);
  scm_c_define_gsubr("meep-fields-use-real-fields", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_use_real_fields);
  scm_c_define_gsubr("meep-fields-zero-fields", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_zero_fields);
  scm_c_define_gsubr("meep-fields-remove-sources", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_remove_sources);
  scm_c_define_gsubr("meep-fields-remove-susceptibilities", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_remove_susceptibilities);
  scm_c_define_gsubr("meep-fields-remove-fluxes", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_remove_fluxes);
  scm_c_define_gsubr("meep-fields-reset", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_reset);
  scm_c_define_gsubr("meep-fields-log", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_log);
  scm_c_define_gsubr("meep-fields-change-m", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_change_m);
  scm_c_define_gsubr("meep-fields-time-spent-on", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_time_spent_on);
  scm_c_define_gsubr("meep-fields-mean-time-spent-on", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_mean_time_spent_on);
  scm_c_define_gsubr("meep-fields-print-times", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_print_times);
  scm_c_define_gsubr("meep-fields-set-boundary", 4, 0, 0, (swig_guile_proc) _wrap_meep_fields_set_boundary);
  scm_c_define_gsubr("meep-fields-use-bloch", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_use_bloch);
  scm_c_define_gsubr("meep-fields-lattice-vector", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_lattice_vector);
  scm_c_define_gsubr("meep-fields-update-eh", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_update_eh);
  scm_c_define_gsubr("meep-fields-total-volume", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_total_volume);
  scm_c_define_gsubr("meep-fields-dump", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_dump);
  scm_c_define_gsubr("meep-fields-load", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_load);
  scm_c_define_gsubr("meep-fields-output-hdf5", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_output_hdf5);
  scm_c_define_gsubr("meep-fields-open-h5file", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_open_h5file);
  scm_c_define_gsubr("meep-fields-h5file-name", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_h5file_name);
  scm_c_define_gsubr("meep-fields-output-times", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_output_times);
  scm_c_define_gsubr("meep-fields-get-array-slice-dimensions", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_get_array_slice_dimensions);
  scm_c_define_gsubr("meep-fields-get-array-slice", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_get_array_slice);
  scm_c_define_gsubr("meep-fields-get-complex-array-slice", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_get_complex_array_slice);
  scm_c_define_gsubr("meep-fields-get-source-slice", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_get_source_slice);
  scm_c_define_gsubr("meep-fields-do-get-array-slice", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_do_get_array_slice);
  scm_c_define_gsubr("meep-fields-get-array-metadata", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_get_array_metadata);
  scm_c_define_gsubr("meep-fields-last-step-output-wall-time-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_last_step_output_wall_time_set);
  scm_c_define_gsubr("meep-fields-last-step-output-wall-time-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_last_step_output_wall_time_get);
  scm_c_define_gsubr("meep-fields-last-step-output-t-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_last_step_output_t_set);
  scm_c_define_gsubr("meep-fields-last-step-output-t-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_last_step_output_t_get);
  scm_c_define_gsubr("meep-fields-step", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_step);
  scm_c_define_gsubr("meep-fields-round-time", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_round_time);
  scm_c_define_gsubr("meep-fields-time", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_time);
  scm_c_define_gsubr("meep-fields-solve-cw", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_solve_cw);
  scm_c_define_gsubr("meep-fields-last-source-time", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_last_source_time);
  scm_c_define_gsubr("meep-fields-add-point-source", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_add_point_source);
  scm_c_define_gsubr("meep-fields-add-volume-source", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_add_volume_source);
  scm_c_define_gsubr("meep-fields-is-aniso2d", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_is_aniso2d);
  scm_c_define_gsubr("meep-fields-require-source-components", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_require_source_components);
  scm_c_define_gsubr("meep-fields--require-component", 3, 0, 0, (swig_guile_proc) _wrap_meep_fields__require_component);
  scm_c_define_gsubr("meep-fields-require-component", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_require_component);
  scm_c_define_gsubr("meep-fields-add-srcdata", 6, 0, 0, (swig_guile_proc) _wrap_meep_fields_add_srcdata);
  scm_c_define_gsubr("meep-fields-register-src-time", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_register_src_time);
  scm_c_define_gsubr("meep-fields-lookup-src-time", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_lookup_src_time);
  scm_c_define_gsubr("meep-fields-get-eigenmode", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_get_eigenmode);
  scm_c_define_gsubr("meep-fields-add-eigenmode-source", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_add_eigenmode_source);
  scm_c_define_gsubr("meep-fields-get-eigenmode-coefficients", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_get_eigenmode_coefficients);
  scm_c_define_gsubr("meep-fields-initialize-field", 3, 0, 0, (swig_guile_proc) _wrap_meep_fields_initialize_field);
  scm_c_define_gsubr("meep-fields-initialize-with-nth-te", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_initialize_with_nth_te);
  scm_c_define_gsubr("meep-fields-initialize-with-nth-tm", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_initialize_with_nth_tm);
  scm_c_define_gsubr("meep-fields-initialize-with-n-te", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_initialize_with_n_te);
  scm_c_define_gsubr("meep-fields-initialize-with-n-tm", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_initialize_with_n_tm);
  scm_c_define_gsubr("meep-fields-phase-in-material", 3, 0, 0, (swig_guile_proc) _wrap_meep_fields_phase_in_material);
  scm_c_define_gsubr("meep-fields-is-phasing", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_is_phasing);
  scm_c_define_gsubr("meep-fields-vec2diel-floor", 3, 0, 0, (swig_guile_proc) _wrap_meep_fields_vec2diel_floor);
  scm_c_define_gsubr("meep-fields-vec2diel-ceil", 3, 0, 0, (swig_guile_proc) _wrap_meep_fields_vec2diel_ceil);
  scm_c_define_gsubr("meep-fields-loop-in-chunks", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_loop_in_chunks);
  scm_c_define_gsubr("meep-fields-integrate", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_integrate);
  scm_c_define_gsubr("meep-fields-integrate2", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_integrate2);
  scm_c_define_gsubr("meep-fields-max-abs", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_max_abs);
  scm_c_define_gsubr("meep-fields-add-dft-pt", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_add_dft_pt);
  scm_c_define_gsubr("meep-fields-add-dft", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_add_dft);
  scm_c_define_gsubr("meep-fields-update-dfts", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_update_dfts);
  scm_c_define_gsubr("meep-fields-dft-norm", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_dft_norm);
  scm_c_define_gsubr("meep-fields-dft-maxfreq", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_dft_maxfreq);
  scm_c_define_gsubr("meep-fields-max-decimation", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_max_decimation);
  scm_c_define_gsubr("meep-fields-clear-dft-monitors", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_clear_dft_monitors);
  scm_c_define_gsubr("meep-fields-add-dft-flux", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_add_dft_flux);
  scm_c_define_gsubr("meep-fields-add-dft-flux-box", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_add_dft_flux_box);
  scm_c_define_gsubr("meep-fields-add-dft-flux-plane", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_add_dft_flux_plane);
  scm_c_define_gsubr("meep-fields-add-mode-monitor", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_add_mode_monitor);
  scm_c_define_gsubr("meep-fields-add-dft-fields", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_add_dft_fields);
  scm_c_define_gsubr("meep-fields-process-dft-component", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_process_dft_component);
  scm_c_define_gsubr("meep-fields-output-dft-components", 5, 0, 0, (swig_guile_proc) _wrap_meep_fields_output_dft_components);
  scm_c_define_gsubr("meep-fields-output-dft", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_output_dft);
  scm_c_define_gsubr("meep-fields-get-dft-array", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_get_dft_array);
  scm_c_define_gsubr("meep-fields-get-overlap", 6, 0, 0, (swig_guile_proc) _wrap_meep_fields_get_overlap);
  scm_c_define_gsubr("meep-fields-get-mode-flux-overlap", 5, 0, 0, (swig_guile_proc) _wrap_meep_fields_get_mode_flux_overlap);
  scm_c_define_gsubr("meep-fields-get-mode-mode-overlap", 5, 0, 0, (swig_guile_proc) _wrap_meep_fields_get_mode_mode_overlap);
  scm_c_define_gsubr("meep-fields-add-dft-energy", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_add_dft_energy);
  scm_c_define_gsubr("meep-fields-add-dft-force", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_add_dft_force);
  scm_c_define_gsubr("meep-fields-add-dft-near2far", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_add_dft_near2far);
  scm_c_define_gsubr("meep-fields-get-inveps", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_get_inveps);
  scm_c_define_gsubr("meep-fields-get-eps", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_get_eps);
  scm_c_define_gsubr("meep-fields-get-mu", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_get_mu);
  scm_c_define_gsubr("meep-fields-get-point", 3, 0, 0, (swig_guile_proc) _wrap_meep_fields_get_point);
  scm_c_define_gsubr("meep-fields-get-new-point", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_get_new_point);
  scm_c_define_gsubr("meep-fields-dft-monitor-size", 4, 0, 0, (swig_guile_proc) _wrap_meep_fields_dft_monitor_size);
  scm_c_define_gsubr("meep-fields-get-dft-component-dims", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_get_dft_component_dims);
  scm_c_define_gsubr("meep-fields-synchronize-magnetic-fields", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_synchronize_magnetic_fields);
  scm_c_define_gsubr("meep-fields-restore-magnetic-fields", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_restore_magnetic_fields);
  scm_c_define_gsubr("meep-fields-energy-in-box", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_energy_in_box);
  scm_c_define_gsubr("meep-fields-electric-energy-in-box", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_electric_energy_in_box);
  scm_c_define_gsubr("meep-fields-magnetic-energy-in-box", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_magnetic_energy_in_box);
  scm_c_define_gsubr("meep-fields-thermo-energy-in-box", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_thermo_energy_in_box);
  scm_c_define_gsubr("meep-fields-total-energy", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_total_energy);
  scm_c_define_gsubr("meep-fields-field-energy-in-box", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_field_energy_in_box);
  scm_c_define_gsubr("meep-fields-field-energy", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_field_energy);
  scm_c_define_gsubr("meep-fields-flux-in-box-wrongH", 3, 0, 0, (swig_guile_proc) _wrap_meep_fields_flux_in_box_wrongH);
  scm_c_define_gsubr("meep-fields-flux-in-box", 3, 0, 0, (swig_guile_proc) _wrap_meep_fields_flux_in_box);
  scm_c_define_gsubr("meep-fields-add-flux-vol", 3, 0, 0, (swig_guile_proc) _wrap_meep_fields_add_flux_vol);
  scm_c_define_gsubr("meep-fields-add-flux-plane", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_add_flux_plane);
  scm_c_define_gsubr("meep-fields-electric-energy-max-in-box", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_electric_energy_max_in_box);
  scm_c_define_gsubr("meep-fields-modal-volume-in-box", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_modal_volume_in_box);
  scm_c_define_gsubr("meep-fields-electric-sqr-weighted-integral", 3, 0, 0, (swig_guile_proc) _wrap_meep_fields_electric_sqr_weighted_integral);
  scm_c_define_gsubr("meep-fields-electric-energy-weighted-integral", 3, 0, 0, (swig_guile_proc) _wrap_meep_fields_electric_energy_weighted_integral);
  scm_c_define_gsubr("meep-fields-set-output-directory", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_set_output_directory);
  scm_c_define_gsubr("meep-fields-count-volume", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_count_volume);
  scm_c_define_gsubr("meep-fields-have-component", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_have_component);
  scm_c_define_gsubr("meep-fields-max-eps", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_max_eps);
  scm_c_define_gsubr("meep-fields-step-boundaries", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_step_boundaries);
  scm_c_define_gsubr("meep-fields-process-incoming-chunk-data", 3, 0, 0, (swig_guile_proc) _wrap_meep_fields_process_incoming_chunk_data);
  scm_c_define_gsubr("meep-fields-nosize-direction", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_nosize_direction);
  scm_c_define_gsubr("meep-fields-normal-direction", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_normal_direction);
  scm_c_define_gsubr("meep-fields-casimir-stress-dct-integral", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_casimir_stress_dct_integral);
  scm_c_define_gsubr("meep-fields-set-solve-cw-omega", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_set_solve_cw_omega);
  scm_c_define_gsubr("meep-fields-unset-solve-cw-omega", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_unset_solve_cw_omega);
  scm_c_define_gsubr("meep-fields-get-field", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_get_field);
  scm_c_define_gsubr("meep-fields-get-chi1inv", 0, 0, 1, (swig_guile_proc) _wrap_meep_fields_get_chi1inv);
  scm_c_define_gsubr("meep-fields-locate-component-point", 4, 0, 0, (swig_guile_proc) _wrap_meep_fields_locate_component_point);
  scm_c_define_gsubr("meep-fields-am-now-working-on", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_am_now_working_on);
  scm_c_define_gsubr("meep-fields-finished-working", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_finished_working);
  scm_c_define_gsubr("meep-fields-get-time-spent-on", 2, 0, 0, (swig_guile_proc) _wrap_meep_fields_get_time_spent_on);
  scm_c_define_gsubr("meep-fields-get-timing-data", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_get_timing_data);
  scm_c_define_gsubr("meep-fields-reset-timers", 1, 0, 0, (swig_guile_proc) _wrap_meep_fields_reset_timers);
  SWIG_TypeClientData(SWIGTYPE_p_meep__flux_vol, (void *) &_swig_guile_clientdatameep_flux_vol);
  scm_c_define_gsubr("new-meep-flux-vol", 3, 0, 0, (swig_guile_proc) _wrap_new_meep_flux_vol);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__flux_vol->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_flux_vol;
  scm_c_define_gsubr("delete-meep-flux-vol", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_flux_vol);
  scm_c_define_gsubr("meep-flux-vol-update-half", 1, 0, 0, (swig_guile_proc) _wrap_meep_flux_vol_update_half);
  scm_c_define_gsubr("meep-flux-vol-update", 1, 0, 0, (swig_guile_proc) _wrap_meep_flux_vol_update);
  scm_c_define_gsubr("meep-flux-vol-flux", 1, 0, 0, (swig_guile_proc) _wrap_meep_flux_vol_flux);
  scm_c_define_gsubr("meep-flux-vol-next-set", 2, 0, 0, (swig_guile_proc) _wrap_meep_flux_vol_next_set);
  scm_c_define_gsubr("meep-flux-vol-next-get", 1, 0, 0, (swig_guile_proc) _wrap_meep_flux_vol_next_get);
  scm_c_define_gsubr("meep-make-output-directory", 0, 0, 1, (swig_guile_proc) _wrap_meep_make_output_directory);
  scm_c_define_gsubr("meep-trash-output-directory", 1, 0, 0, (swig_guile_proc) _wrap_meep_trash_output_directory);
  scm_c_define_gsubr("meep-delete-directory", 1, 0, 0, (swig_guile_proc) _wrap_meep_delete_directory);
  scm_c_define_gsubr("meep-create-output-file", 2, 0, 0, (swig_guile_proc) _wrap_meep_create_output_file);
  scm_c_define_gsubr("meep-do-harminv", 0, 0, 1, (swig_guile_proc) _wrap_meep_do_harminv);
  scm_c_define_gsubr("make-casimir-gfunc", 0, 0, 1, (swig_guile_proc) _wrap_make_casimir_gfunc);
  scm_c_define_gsubr("meep-make-casimir-gfunc-kz", 4, 0, 0, (swig_guile_proc) _wrap_meep_make_casimir_gfunc_kz);
  scm_c_define_gsubr("meep-set-random-seed", 1, 0, 0, (swig_guile_proc) _wrap_meep_set_random_seed);
  scm_c_define_gsubr("meep-restore-random-seed", 0, 0, 0, (swig_guile_proc) _wrap_meep_restore_random_seed);
  scm_c_define_gsubr("meep-uniform-random", 2, 0, 0, (swig_guile_proc) _wrap_meep_uniform_random);
  scm_c_define_gsubr("meep-gaussian-random", 2, 0, 0, (swig_guile_proc) _wrap_meep_gaussian_random);
  scm_c_define_gsubr("meep-random-int", 2, 0, 0, (swig_guile_proc) _wrap_meep_random_int);
  scm_c_define_gsubr("meep-BesselJ", 2, 0, 0, (swig_guile_proc) _wrap_meep_BesselJ);
  scm_c_define_gsubr("meep-green2d", 8, 0, 0, (swig_guile_proc) _wrap_meep_green2d);
  scm_c_define_gsubr("meep-green3d", 8, 0, 0, (swig_guile_proc) _wrap_meep_green3d);
  scm_c_define_gsubr("meep-destroy-eigenmode-data", 0, 0, 1, (swig_guile_proc) _wrap_meep_destroy_eigenmode_data);
  scm_c_define_gsubr("meep-eigenmode-amplitude", 3, 0, 0, (swig_guile_proc) _wrap_meep_eigenmode_amplitude);
  scm_c_define_gsubr("meep-get-group-velocity", 1, 0, 0, (swig_guile_proc) _wrap_meep_get_group_velocity);
  scm_c_define_gsubr("meep-get-k", 1, 0, 0, (swig_guile_proc) _wrap_meep_get_k);
  scm_c_define_gsubr("meep-linear-interpolate", 8, 0, 0, (swig_guile_proc) _wrap_meep_linear_interpolate);
  SWIG_TypeClientData(SWIGTYPE_p_meep__split_plane, (void *) &_swig_guile_clientdatasplit_plane);
  scm_c_define_gsubr("split-plane-dir-set", 2, 0, 0, (swig_guile_proc) _wrap_split_plane_dir_set);
  scm_c_define_gsubr("split-plane-dir-get", 1, 0, 0, (swig_guile_proc) _wrap_split_plane_dir_get);
  scm_c_define_gsubr("split-plane-pos-set", 2, 0, 0, (swig_guile_proc) _wrap_split_plane_pos_set);
  scm_c_define_gsubr("split-plane-pos-get", 1, 0, 0, (swig_guile_proc) _wrap_split_plane_pos_get);
  scm_c_define_gsubr("new-split-plane", 0, 0, 0, (swig_guile_proc) _wrap_new_split_plane);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__split_plane->clientdata))->destroy = (guile_destructor) _wrap_delete_split_plane;
  scm_c_define_gsubr("delete-split-plane", 1, 0, 0, (swig_guile_proc) _wrap_delete_split_plane);
  SWIG_TypeClientData(SWIGTYPE_p_meep__binary_partition, (void *) &_swig_guile_clientdatameep_binary_partition);
  scm_c_define_gsubr("new-meep-binary-partition", 0, 0, 1, (swig_guile_proc) _wrap_new_meep_binary_partition);
  scm_c_define_gsubr("meep-binary-partition-is-leaf", 1, 0, 0, (swig_guile_proc) _wrap_meep_binary_partition_is_leaf);
  scm_c_define_gsubr("meep-binary-partition-get-proc-id", 1, 0, 0, (swig_guile_proc) _wrap_meep_binary_partition_get_proc_id);
  scm_c_define_gsubr("meep-binary-partition-get-plane", 1, 0, 0, (swig_guile_proc) _wrap_meep_binary_partition_get_plane);
  scm_c_define_gsubr("meep-binary-partition-left-tree", 1, 0, 0, (swig_guile_proc) _wrap_meep_binary_partition_left_tree);
  scm_c_define_gsubr("meep-binary-partition-right-tree", 1, 0, 0, (swig_guile_proc) _wrap_meep_binary_partition_right_tree);
  ((swig_guile_clientdata *)(SWIGTYPE_p_meep__binary_partition->clientdata))->destroy = (guile_destructor) _wrap_delete_meep_binary_partition;
  scm_c_define_gsubr("delete-meep-binary-partition", 1, 0, 0, (swig_guile_proc) _wrap_delete_meep_binary_partition);
  scm_c_define_gsubr("meep-set-zero-subnormals", 1, 0, 0, (swig_guile_proc) _wrap_meep_set_zero_subnormals);
  scm_c_define_gsubr("meep-setup", 0, 0, 0, (swig_guile_proc) _wrap_meep_setup);
  scm_c_define_gsubr("meep-split-into-tiles", 3, 0, 0, (swig_guile_proc) _wrap_meep_split_into_tiles);
  scm_c_define_gsubr("meep-check-tiles", 2, 0, 0, (swig_guile_proc) _wrap_meep_check_tiles);
  scm_c_define_gsubr("MEEP-CTL-SWIG-HPP", 0, 0, 0, (swig_guile_proc) _wrap_MEEP_CTL_SWIG_HPP);
  SWIG_TypeClientData(SWIGTYPE_p_kpoint_list, (void *) &_swig_guile_clientdatakpoint_list);
  scm_c_define_gsubr("kpoint-list-kpoints-set", 2, 0, 0, (swig_guile_proc) _wrap_kpoint_list_kpoints_set);
  scm_c_define_gsubr("kpoint-list-kpoints-get", 1, 0, 0, (swig_guile_proc) _wrap_kpoint_list_kpoints_get);
  scm_c_define_gsubr("kpoint-list-n-set", 2, 0, 0, (swig_guile_proc) _wrap_kpoint_list_n_set);
  scm_c_define_gsubr("kpoint-list-n-get", 1, 0, 0, (swig_guile_proc) _wrap_kpoint_list_n_get);
  scm_c_define_gsubr("kpoint-list-kdom-set", 2, 0, 0, (swig_guile_proc) _wrap_kpoint_list_kdom_set);
  scm_c_define_gsubr("kpoint-list-kdom-get", 1, 0, 0, (swig_guile_proc) _wrap_kpoint_list_kdom_get);
  scm_c_define_gsubr("kpoint-list-num-bands-set", 2, 0, 0, (swig_guile_proc) _wrap_kpoint_list_num_bands_set);
  scm_c_define_gsubr("kpoint-list-num-bands-get", 1, 0, 0, (swig_guile_proc) _wrap_kpoint_list_num_bands_get);
  scm_c_define_gsubr("new-kpoint-list", 0, 0, 0, (swig_guile_proc) _wrap_new_kpoint_list);
  ((swig_guile_clientdata *)(SWIGTYPE_p_kpoint_list->clientdata))->destroy = (guile_destructor) _wrap_delete_kpoint_list;
  scm_c_define_gsubr("delete-kpoint-list", 1, 0, 0, (swig_guile_proc) _wrap_delete_kpoint_list);
  scm_c_define_gsubr("vec-to-vector3", 1, 0, 0, (swig_guile_proc) _wrap_vec_to_vector3);
  scm_c_define_gsubr("vector3-to-vec", 1, 0, 0, (swig_guile_proc) _wrap_vector3_to_vec);
  scm_c_define_gsubr("set-dimensions", 1, 0, 0, (swig_guile_proc) _wrap_set_dimensions);
  scm_c_define_gsubr("make-structure", 0, 0, 1, (swig_guile_proc) _wrap_make_structure_rest);
  scm_c_define_gsubr("do-harminv", 0, 0, 1, (swig_guile_proc) _wrap_do_harminv_rest);
  scm_c_define_gsubr("do-get-eigenmode-coefficients", 0, 0, 1, (swig_guile_proc) _wrap_do_get_eigenmode_coefficients_rest);
  scm_c_define_gsubr("dft-flux-flux", 1, 0, 0, (swig_guile_proc) _wrap_dft_flux_flux);
  scm_c_define_gsubr("dft-energy-electric", 1, 0, 0, (swig_guile_proc) _wrap_dft_energy_electric);
  scm_c_define_gsubr("dft-energy-magnetic", 1, 0, 0, (swig_guile_proc) _wrap_dft_energy_magnetic);
  scm_c_define_gsubr("dft-energy-total", 1, 0, 0, (swig_guile_proc) _wrap_dft_energy_total);
  scm_c_define_gsubr("dft-force-force", 1, 0, 0, (swig_guile_proc) _wrap_dft_force_force);
  scm_c_define_gsubr("dft-ldos-ldos", 1, 0, 0, (swig_guile_proc) _wrap_dft_ldos_ldos);
  scm_c_define_gsubr("dft-ldos-F", 1, 0, 0, (swig_guile_proc) _wrap_dft_ldos_F);
  scm_c_define_gsubr("dft-ldos-J", 1, 0, 0, (swig_guile_proc) _wrap_dft_ldos_J);
  scm_c_define_gsubr("dft-near2far-farfield", 2, 0, 0, (swig_guile_proc) _wrap_dft_near2far_farfield);
  scm_c_define_gsubr("dft-near2far-flux", 4, 0, 0, (swig_guile_proc) _wrap_dft_near2far_flux);
  scm_c_define_gsubr("make-casimir-g", 0, 0, 1, (swig_guile_proc) _wrap_make_casimir_g);
  scm_c_define_gsubr("make-casimir-g-kz", 4, 0, 0, (swig_guile_proc) _wrap_make_casimir_g_kz);
  scm_c_define_gsubr("make-volume-list", 4, 0, 0, (swig_guile_proc) _wrap_make_volume_list);
  scm_c_define_gsubr("std-vector-double-to-scm", 1, 0, 0, (swig_guile_proc) _wrap_std_vector_double_to_scm);
}

#ifdef __cplusplus
}
#endif
extern "C" {
/* Linkage: simple */

}

