python-syfi 1.0.0.dfsg-1.2 / usr / share / pyshared / SyFi.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.10
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.



from sys import version_info
if version_info >= (3,0,0):
    new_instancemethod = lambda func, inst, cls: _SyFi.SWIG_PyInstanceMethod_New(func)
else:
    from new import instancemethod as new_instancemethod
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_SyFi', [dirname(__file__)])
        except ImportError:
            import _SyFi
            return _SyFi
        if fp is not None:
            try:
                _mod = imp.load_module('_SyFi', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _SyFi = swig_import_helper()
    del swig_import_helper
else:
    import _SyFi
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


def _swig_setattr_nondynamic_method(set):
    def set_attr(self,name,value):
        if (name == "thisown"): return self.this.own(value)
        if hasattr(self,name) or (name == "this"):
            set(self,name,value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr



def setDigits(*args):
  """setDigits(int a)"""
  return _SyFi.setDigits(*args)
GINACLIB_MAJOR_VERSION = _SyFi.GINACLIB_MAJOR_VERSION
GINACLIB_MINOR_VERSION = _SyFi.GINACLIB_MINOR_VERSION
GINACLIB_MICRO_VERSION = _SyFi.GINACLIB_MICRO_VERSION
class SwigPyIterator(object):
    """Proxy of C++ swig::SwigPyIterator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _SyFi.delete_SwigPyIterator
    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _SyFi.SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        incr(SwigPyIterator self) -> SwigPyIterator
        """
        return _SyFi.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        decr(SwigPyIterator self) -> SwigPyIterator
        """
        return _SyFi.SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _SyFi.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _SyFi.SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _SyFi.SwigPyIterator_copy(self)

    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _SyFi.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _SyFi.SwigPyIterator___next__(self)

    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _SyFi.SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _SyFi.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _SyFi.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _SyFi.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _SyFi.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _SyFi.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _SyFi.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _SyFi.SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
SwigPyIterator.value = new_instancemethod(_SyFi.SwigPyIterator_value,None,SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_SyFi.SwigPyIterator_incr,None,SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_SyFi.SwigPyIterator_decr,None,SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_SyFi.SwigPyIterator_distance,None,SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_SyFi.SwigPyIterator_equal,None,SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_SyFi.SwigPyIterator_copy,None,SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_SyFi.SwigPyIterator_next,None,SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_SyFi.SwigPyIterator___next__,None,SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_SyFi.SwigPyIterator_previous,None,SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_SyFi.SwigPyIterator_advance,None,SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_SyFi.SwigPyIterator___eq__,None,SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_SyFi.SwigPyIterator___ne__,None,SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_SyFi.SwigPyIterator___iadd__,None,SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_SyFi.SwigPyIterator___isub__,None,SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_SyFi.SwigPyIterator___add__,None,SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_SyFi.SwigPyIterator___sub__,None,SwigPyIterator)
SwigPyIterator_swigregister = _SyFi.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class exvector(object):
    """Proxy of C++ std::vector<(GiNaC::ex)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(exvector self) -> SwigPyIterator"""
        return _SyFi.exvector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(exvector self) -> bool"""
        return _SyFi.exvector___nonzero__(self)

    def __bool__(self):
        """__bool__(exvector self) -> bool"""
        return _SyFi.exvector___bool__(self)

    def __len__(self):
        """__len__(exvector self) -> std::vector< GiNaC::ex >::size_type"""
        return _SyFi.exvector___len__(self)

    def pop(self):
        """pop(exvector self) -> std::vector< GiNaC::ex >::value_type"""
        return _SyFi.exvector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(exvector self, std::vector< GiNaC::ex >::difference_type i, std::vector< GiNaC::ex >::difference_type j) -> exvector"""
        return _SyFi.exvector___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(exvector self, std::vector< GiNaC::ex >::difference_type i, std::vector< GiNaC::ex >::difference_type j, 
            exvector v=std::vector< GiNaC::ex,std::allocator< GiNaC::ex > >())
        __setslice__(exvector self, std::vector< GiNaC::ex >::difference_type i, std::vector< GiNaC::ex >::difference_type j)
        """
        return _SyFi.exvector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(exvector self, std::vector< GiNaC::ex >::difference_type i, std::vector< GiNaC::ex >::difference_type j)"""
        return _SyFi.exvector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(exvector self, std::vector< GiNaC::ex >::difference_type i)
        __delitem__(exvector self, PySliceObject * slice)
        """
        return _SyFi.exvector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(exvector self, PySliceObject * slice) -> exvector
        __getitem__(exvector self, std::vector< GiNaC::ex >::difference_type i) -> std::vector< GiNaC::ex >::value_type const &
        """
        return _SyFi.exvector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(exvector self, PySliceObject * slice, exvector v)
        __setitem__(exvector self, PySliceObject * slice)
        __setitem__(exvector self, std::vector< GiNaC::ex >::difference_type i, std::vector< GiNaC::ex >::value_type const & x)
        """
        return _SyFi.exvector___setitem__(self, *args)

    def append(self, *args):
        """append(exvector self, std::vector< GiNaC::ex >::value_type const & x)"""
        return _SyFi.exvector_append(self, *args)

    def empty(self):
        """empty(exvector self) -> bool"""
        return _SyFi.exvector_empty(self)

    def size(self):
        """size(exvector self) -> std::vector< GiNaC::ex >::size_type"""
        return _SyFi.exvector_size(self)

    def clear(self):
        """clear(exvector self)"""
        return _SyFi.exvector_clear(self)

    def swap(self, *args):
        """swap(exvector self, exvector v)"""
        return _SyFi.exvector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(exvector self) -> std::vector< GiNaC::ex >::allocator_type"""
        return _SyFi.exvector_get_allocator(self)

    def begin(self):
        """begin(exvector self) -> std::vector< GiNaC::ex >::iterator"""
        return _SyFi.exvector_begin(self)

    def end(self):
        """end(exvector self) -> std::vector< GiNaC::ex >::iterator"""
        return _SyFi.exvector_end(self)

    def rbegin(self):
        """rbegin(exvector self) -> std::vector< GiNaC::ex >::reverse_iterator"""
        return _SyFi.exvector_rbegin(self)

    def rend(self):
        """rend(exvector self) -> std::vector< GiNaC::ex >::reverse_iterator"""
        return _SyFi.exvector_rend(self)

    def pop_back(self):
        """pop_back(exvector self)"""
        return _SyFi.exvector_pop_back(self)

    def erase(self, *args):
        """
        erase(exvector self, std::vector< GiNaC::ex >::iterator pos) -> std::vector< GiNaC::ex >::iterator
        erase(exvector self, std::vector< GiNaC::ex >::iterator first, std::vector< GiNaC::ex >::iterator last) -> std::vector< GiNaC::ex >::iterator
        """
        return _SyFi.exvector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(GiNaC::ex)> self) -> exvector
        __init__(std::vector<(GiNaC::ex)> self, exvector arg2) -> exvector
        __init__(std::vector<(GiNaC::ex)> self, std::vector< GiNaC::ex >::size_type size) -> exvector
        __init__(std::vector<(GiNaC::ex)> self, std::vector< GiNaC::ex >::size_type size, std::vector< GiNaC::ex >::value_type const & value) -> exvector
        """
        _SyFi.exvector_swiginit(self,_SyFi.new_exvector(*args))
    def push_back(self, *args):
        """push_back(exvector self, std::vector< GiNaC::ex >::value_type const & x)"""
        return _SyFi.exvector_push_back(self, *args)

    def front(self):
        """front(exvector self) -> std::vector< GiNaC::ex >::value_type const &"""
        return _SyFi.exvector_front(self)

    def back(self):
        """back(exvector self) -> std::vector< GiNaC::ex >::value_type const &"""
        return _SyFi.exvector_back(self)

    def assign(self, *args):
        """assign(exvector self, std::vector< GiNaC::ex >::size_type n, std::vector< GiNaC::ex >::value_type const & x)"""
        return _SyFi.exvector_assign(self, *args)

    def resize(self, *args):
        """
        resize(exvector self, std::vector< GiNaC::ex >::size_type new_size)
        resize(exvector self, std::vector< GiNaC::ex >::size_type new_size, std::vector< GiNaC::ex >::value_type const & x)
        """
        return _SyFi.exvector_resize(self, *args)

    def insert(self, *args):
        """
        insert(exvector self, std::vector< GiNaC::ex >::iterator pos, std::vector< GiNaC::ex >::value_type const & x) -> std::vector< GiNaC::ex >::iterator
        insert(exvector self, std::vector< GiNaC::ex >::iterator pos, std::vector< GiNaC::ex >::size_type n, std::vector< GiNaC::ex >::value_type const & x)
        """
        return _SyFi.exvector_insert(self, *args)

    def reserve(self, *args):
        """reserve(exvector self, std::vector< GiNaC::ex >::size_type n)"""
        return _SyFi.exvector_reserve(self, *args)

    def capacity(self):
        """capacity(exvector self) -> std::vector< GiNaC::ex >::size_type"""
        return _SyFi.exvector_capacity(self)

    __swig_destroy__ = _SyFi.delete_exvector
exvector.iterator = new_instancemethod(_SyFi.exvector_iterator,None,exvector)
exvector.__nonzero__ = new_instancemethod(_SyFi.exvector___nonzero__,None,exvector)
exvector.__bool__ = new_instancemethod(_SyFi.exvector___bool__,None,exvector)
exvector.__len__ = new_instancemethod(_SyFi.exvector___len__,None,exvector)
exvector.pop = new_instancemethod(_SyFi.exvector_pop,None,exvector)
exvector.__getslice__ = new_instancemethod(_SyFi.exvector___getslice__,None,exvector)
exvector.__setslice__ = new_instancemethod(_SyFi.exvector___setslice__,None,exvector)
exvector.__delslice__ = new_instancemethod(_SyFi.exvector___delslice__,None,exvector)
exvector.__delitem__ = new_instancemethod(_SyFi.exvector___delitem__,None,exvector)
exvector.__getitem__ = new_instancemethod(_SyFi.exvector___getitem__,None,exvector)
exvector.__setitem__ = new_instancemethod(_SyFi.exvector___setitem__,None,exvector)
exvector.append = new_instancemethod(_SyFi.exvector_append,None,exvector)
exvector.empty = new_instancemethod(_SyFi.exvector_empty,None,exvector)
exvector.size = new_instancemethod(_SyFi.exvector_size,None,exvector)
exvector.clear = new_instancemethod(_SyFi.exvector_clear,None,exvector)
exvector.swap = new_instancemethod(_SyFi.exvector_swap,None,exvector)
exvector.get_allocator = new_instancemethod(_SyFi.exvector_get_allocator,None,exvector)
exvector.begin = new_instancemethod(_SyFi.exvector_begin,None,exvector)
exvector.end = new_instancemethod(_SyFi.exvector_end,None,exvector)
exvector.rbegin = new_instancemethod(_SyFi.exvector_rbegin,None,exvector)
exvector.rend = new_instancemethod(_SyFi.exvector_rend,None,exvector)
exvector.pop_back = new_instancemethod(_SyFi.exvector_pop_back,None,exvector)
exvector.erase = new_instancemethod(_SyFi.exvector_erase,None,exvector)
exvector.push_back = new_instancemethod(_SyFi.exvector_push_back,None,exvector)
exvector.front = new_instancemethod(_SyFi.exvector_front,None,exvector)
exvector.back = new_instancemethod(_SyFi.exvector_back,None,exvector)
exvector.assign = new_instancemethod(_SyFi.exvector_assign,None,exvector)
exvector.resize = new_instancemethod(_SyFi.exvector_resize,None,exvector)
exvector.insert = new_instancemethod(_SyFi.exvector_insert,None,exvector)
exvector.reserve = new_instancemethod(_SyFi.exvector_reserve,None,exvector)
exvector.capacity = new_instancemethod(_SyFi.exvector_capacity,None,exvector)
exvector_swigregister = _SyFi.exvector_swigregister
exvector_swigregister(exvector)

class exmap(object):
    """Proxy of C++ std::map<(GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(exmap self) -> SwigPyIterator"""
        return _SyFi.exmap_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(exmap self) -> bool"""
        return _SyFi.exmap___nonzero__(self)

    def __bool__(self):
        """__bool__(exmap self) -> bool"""
        return _SyFi.exmap___bool__(self)

    def __len__(self):
        """__len__(exmap self) -> std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::size_type"""
        return _SyFi.exmap___len__(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __getitem__(self, *args):
        """__getitem__(exmap self, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::key_type const & key) -> std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::mapped_type const &"""
        return _SyFi.exmap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(exmap self, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::key_type const & key)"""
        return _SyFi.exmap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(exmap self, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::key_type const & key) -> bool"""
        return _SyFi.exmap_has_key(self, *args)

    def keys(self):
        """keys(exmap self) -> PyObject *"""
        return _SyFi.exmap_keys(self)

    def values(self):
        """values(exmap self) -> PyObject *"""
        return _SyFi.exmap_values(self)

    def items(self):
        """items(exmap self) -> PyObject *"""
        return _SyFi.exmap_items(self)

    def __contains__(self, *args):
        """__contains__(exmap self, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::key_type const & key) -> bool"""
        return _SyFi.exmap___contains__(self, *args)

    def key_iterator(self):
        """key_iterator(exmap self) -> SwigPyIterator"""
        return _SyFi.exmap_key_iterator(self)

    def value_iterator(self):
        """value_iterator(exmap self) -> SwigPyIterator"""
        return _SyFi.exmap_value_iterator(self)

    def __setitem__(self, *args):
        """
        __setitem__(exmap self, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::key_type const & key)
        __setitem__(exmap self, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::key_type const & key, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::mapped_type const & x)
        """
        return _SyFi.exmap___setitem__(self, *args)

    def asdict(self):
        """asdict(exmap self) -> PyObject *"""
        return _SyFi.exmap_asdict(self)

    def __init__(self, *args): 
        """
        __init__(std::map<(GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less)> self, GiNaC::ex_is_less const & arg2) -> exmap
        __init__(std::map<(GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less)> self) -> exmap
        __init__(std::map<(GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less)> self, exmap arg2) -> exmap
        """
        _SyFi.exmap_swiginit(self,_SyFi.new_exmap(*args))
    def empty(self):
        """empty(exmap self) -> bool"""
        return _SyFi.exmap_empty(self)

    def size(self):
        """size(exmap self) -> std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::size_type"""
        return _SyFi.exmap_size(self)

    def clear(self):
        """clear(exmap self)"""
        return _SyFi.exmap_clear(self)

    def swap(self, *args):
        """swap(exmap self, exmap v)"""
        return _SyFi.exmap_swap(self, *args)

    def get_allocator(self):
        """get_allocator(exmap self) -> std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::allocator_type"""
        return _SyFi.exmap_get_allocator(self)

    def begin(self):
        """begin(exmap self) -> std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::iterator"""
        return _SyFi.exmap_begin(self)

    def end(self):
        """end(exmap self) -> std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::iterator"""
        return _SyFi.exmap_end(self)

    def rbegin(self):
        """rbegin(exmap self) -> std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::reverse_iterator"""
        return _SyFi.exmap_rbegin(self)

    def rend(self):
        """rend(exmap self) -> std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::reverse_iterator"""
        return _SyFi.exmap_rend(self)

    def count(self, *args):
        """count(exmap self, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::key_type const & x) -> std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::size_type"""
        return _SyFi.exmap_count(self, *args)

    def erase(self, *args):
        """
        erase(exmap self, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::key_type const & x) -> std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::size_type
        erase(exmap self, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::iterator position)
        erase(exmap self, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::iterator first, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::iterator last)
        """
        return _SyFi.exmap_erase(self, *args)

    def find(self, *args):
        """find(exmap self, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::key_type const & x) -> std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::iterator"""
        return _SyFi.exmap_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(exmap self, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::key_type const & x) -> std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::iterator"""
        return _SyFi.exmap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(exmap self, std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::key_type const & x) -> std::map< GiNaC::ex,GiNaC::ex,GiNaC::ex_is_less >::iterator"""
        return _SyFi.exmap_upper_bound(self, *args)

    __swig_destroy__ = _SyFi.delete_exmap
exmap.iterator = new_instancemethod(_SyFi.exmap_iterator,None,exmap)
exmap.__nonzero__ = new_instancemethod(_SyFi.exmap___nonzero__,None,exmap)
exmap.__bool__ = new_instancemethod(_SyFi.exmap___bool__,None,exmap)
exmap.__len__ = new_instancemethod(_SyFi.exmap___len__,None,exmap)
exmap.__getitem__ = new_instancemethod(_SyFi.exmap___getitem__,None,exmap)
exmap.__delitem__ = new_instancemethod(_SyFi.exmap___delitem__,None,exmap)
exmap.has_key = new_instancemethod(_SyFi.exmap_has_key,None,exmap)
exmap.keys = new_instancemethod(_SyFi.exmap_keys,None,exmap)
exmap.values = new_instancemethod(_SyFi.exmap_values,None,exmap)
exmap.items = new_instancemethod(_SyFi.exmap_items,None,exmap)
exmap.__contains__ = new_instancemethod(_SyFi.exmap___contains__,None,exmap)
exmap.key_iterator = new_instancemethod(_SyFi.exmap_key_iterator,None,exmap)
exmap.value_iterator = new_instancemethod(_SyFi.exmap_value_iterator,None,exmap)
exmap.__setitem__ = new_instancemethod(_SyFi.exmap___setitem__,None,exmap)
exmap.asdict = new_instancemethod(_SyFi.exmap_asdict,None,exmap)
exmap.empty = new_instancemethod(_SyFi.exmap_empty,None,exmap)
exmap.size = new_instancemethod(_SyFi.exmap_size,None,exmap)
exmap.clear = new_instancemethod(_SyFi.exmap_clear,None,exmap)
exmap.swap = new_instancemethod(_SyFi.exmap_swap,None,exmap)
exmap.get_allocator = new_instancemethod(_SyFi.exmap_get_allocator,None,exmap)
exmap.begin = new_instancemethod(_SyFi.exmap_begin,None,exmap)
exmap.end = new_instancemethod(_SyFi.exmap_end,None,exmap)
exmap.rbegin = new_instancemethod(_SyFi.exmap_rbegin,None,exmap)
exmap.rend = new_instancemethod(_SyFi.exmap_rend,None,exmap)
exmap.count = new_instancemethod(_SyFi.exmap_count,None,exmap)
exmap.erase = new_instancemethod(_SyFi.exmap_erase,None,exmap)
exmap.find = new_instancemethod(_SyFi.exmap_find,None,exmap)
exmap.lower_bound = new_instancemethod(_SyFi.exmap_lower_bound,None,exmap)
exmap.upper_bound = new_instancemethod(_SyFi.exmap_upper_bound,None,exmap)
exmap_swigregister = _SyFi.exmap_swigregister
exmap_swigregister(exmap)

class ex_int_map(object):
    """Proxy of C++ std::map<(GiNaC::ex,int,GiNaC::ex_is_less)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(ex_int_map self) -> SwigPyIterator"""
        return _SyFi.ex_int_map_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(ex_int_map self) -> bool"""
        return _SyFi.ex_int_map___nonzero__(self)

    def __bool__(self):
        """__bool__(ex_int_map self) -> bool"""
        return _SyFi.ex_int_map___bool__(self)

    def __len__(self):
        """__len__(ex_int_map self) -> std::map< GiNaC::ex,int,GiNaC::ex_is_less >::size_type"""
        return _SyFi.ex_int_map___len__(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __getitem__(self, *args):
        """__getitem__(ex_int_map self, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::key_type const & key) -> std::map< GiNaC::ex,int,GiNaC::ex_is_less >::mapped_type const &"""
        return _SyFi.ex_int_map___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(ex_int_map self, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::key_type const & key)"""
        return _SyFi.ex_int_map___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(ex_int_map self, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::key_type const & key) -> bool"""
        return _SyFi.ex_int_map_has_key(self, *args)

    def keys(self):
        """keys(ex_int_map self) -> PyObject *"""
        return _SyFi.ex_int_map_keys(self)

    def values(self):
        """values(ex_int_map self) -> PyObject *"""
        return _SyFi.ex_int_map_values(self)

    def items(self):
        """items(ex_int_map self) -> PyObject *"""
        return _SyFi.ex_int_map_items(self)

    def __contains__(self, *args):
        """__contains__(ex_int_map self, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::key_type const & key) -> bool"""
        return _SyFi.ex_int_map___contains__(self, *args)

    def key_iterator(self):
        """key_iterator(ex_int_map self) -> SwigPyIterator"""
        return _SyFi.ex_int_map_key_iterator(self)

    def value_iterator(self):
        """value_iterator(ex_int_map self) -> SwigPyIterator"""
        return _SyFi.ex_int_map_value_iterator(self)

    def __setitem__(self, *args):
        """
        __setitem__(ex_int_map self, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::key_type const & key)
        __setitem__(ex_int_map self, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::key_type const & key, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::mapped_type const & x)
        """
        return _SyFi.ex_int_map___setitem__(self, *args)

    def asdict(self):
        """asdict(ex_int_map self) -> PyObject *"""
        return _SyFi.ex_int_map_asdict(self)

    def __init__(self, *args): 
        """
        __init__(std::map<(GiNaC::ex,int,GiNaC::ex_is_less)> self, GiNaC::ex_is_less const & arg2) -> ex_int_map
        __init__(std::map<(GiNaC::ex,int,GiNaC::ex_is_less)> self) -> ex_int_map
        __init__(std::map<(GiNaC::ex,int,GiNaC::ex_is_less)> self, ex_int_map arg2) -> ex_int_map
        """
        _SyFi.ex_int_map_swiginit(self,_SyFi.new_ex_int_map(*args))
    def empty(self):
        """empty(ex_int_map self) -> bool"""
        return _SyFi.ex_int_map_empty(self)

    def size(self):
        """size(ex_int_map self) -> std::map< GiNaC::ex,int,GiNaC::ex_is_less >::size_type"""
        return _SyFi.ex_int_map_size(self)

    def clear(self):
        """clear(ex_int_map self)"""
        return _SyFi.ex_int_map_clear(self)

    def swap(self, *args):
        """swap(ex_int_map self, ex_int_map v)"""
        return _SyFi.ex_int_map_swap(self, *args)

    def get_allocator(self):
        """get_allocator(ex_int_map self) -> std::map< GiNaC::ex,int,GiNaC::ex_is_less >::allocator_type"""
        return _SyFi.ex_int_map_get_allocator(self)

    def begin(self):
        """begin(ex_int_map self) -> std::map< GiNaC::ex,int,GiNaC::ex_is_less >::iterator"""
        return _SyFi.ex_int_map_begin(self)

    def end(self):
        """end(ex_int_map self) -> std::map< GiNaC::ex,int,GiNaC::ex_is_less >::iterator"""
        return _SyFi.ex_int_map_end(self)

    def rbegin(self):
        """rbegin(ex_int_map self) -> std::map< GiNaC::ex,int,GiNaC::ex_is_less >::reverse_iterator"""
        return _SyFi.ex_int_map_rbegin(self)

    def rend(self):
        """rend(ex_int_map self) -> std::map< GiNaC::ex,int,GiNaC::ex_is_less >::reverse_iterator"""
        return _SyFi.ex_int_map_rend(self)

    def count(self, *args):
        """count(ex_int_map self, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::key_type const & x) -> std::map< GiNaC::ex,int,GiNaC::ex_is_less >::size_type"""
        return _SyFi.ex_int_map_count(self, *args)

    def erase(self, *args):
        """
        erase(ex_int_map self, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::key_type const & x) -> std::map< GiNaC::ex,int,GiNaC::ex_is_less >::size_type
        erase(ex_int_map self, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::iterator position)
        erase(ex_int_map self, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::iterator first, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::iterator last)
        """
        return _SyFi.ex_int_map_erase(self, *args)

    def find(self, *args):
        """find(ex_int_map self, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::key_type const & x) -> std::map< GiNaC::ex,int,GiNaC::ex_is_less >::iterator"""
        return _SyFi.ex_int_map_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(ex_int_map self, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::key_type const & x) -> std::map< GiNaC::ex,int,GiNaC::ex_is_less >::iterator"""
        return _SyFi.ex_int_map_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(ex_int_map self, std::map< GiNaC::ex,int,GiNaC::ex_is_less >::key_type const & x) -> std::map< GiNaC::ex,int,GiNaC::ex_is_less >::iterator"""
        return _SyFi.ex_int_map_upper_bound(self, *args)

    __swig_destroy__ = _SyFi.delete_ex_int_map
ex_int_map.iterator = new_instancemethod(_SyFi.ex_int_map_iterator,None,ex_int_map)
ex_int_map.__nonzero__ = new_instancemethod(_SyFi.ex_int_map___nonzero__,None,ex_int_map)
ex_int_map.__bool__ = new_instancemethod(_SyFi.ex_int_map___bool__,None,ex_int_map)
ex_int_map.__len__ = new_instancemethod(_SyFi.ex_int_map___len__,None,ex_int_map)
ex_int_map.__getitem__ = new_instancemethod(_SyFi.ex_int_map___getitem__,None,ex_int_map)
ex_int_map.__delitem__ = new_instancemethod(_SyFi.ex_int_map___delitem__,None,ex_int_map)
ex_int_map.has_key = new_instancemethod(_SyFi.ex_int_map_has_key,None,ex_int_map)
ex_int_map.keys = new_instancemethod(_SyFi.ex_int_map_keys,None,ex_int_map)
ex_int_map.values = new_instancemethod(_SyFi.ex_int_map_values,None,ex_int_map)
ex_int_map.items = new_instancemethod(_SyFi.ex_int_map_items,None,ex_int_map)
ex_int_map.__contains__ = new_instancemethod(_SyFi.ex_int_map___contains__,None,ex_int_map)
ex_int_map.key_iterator = new_instancemethod(_SyFi.ex_int_map_key_iterator,None,ex_int_map)
ex_int_map.value_iterator = new_instancemethod(_SyFi.ex_int_map_value_iterator,None,ex_int_map)
ex_int_map.__setitem__ = new_instancemethod(_SyFi.ex_int_map___setitem__,None,ex_int_map)
ex_int_map.asdict = new_instancemethod(_SyFi.ex_int_map_asdict,None,ex_int_map)
ex_int_map.empty = new_instancemethod(_SyFi.ex_int_map_empty,None,ex_int_map)
ex_int_map.size = new_instancemethod(_SyFi.ex_int_map_size,None,ex_int_map)
ex_int_map.clear = new_instancemethod(_SyFi.ex_int_map_clear,None,ex_int_map)
ex_int_map.swap = new_instancemethod(_SyFi.ex_int_map_swap,None,ex_int_map)
ex_int_map.get_allocator = new_instancemethod(_SyFi.ex_int_map_get_allocator,None,ex_int_map)
ex_int_map.begin = new_instancemethod(_SyFi.ex_int_map_begin,None,ex_int_map)
ex_int_map.end = new_instancemethod(_SyFi.ex_int_map_end,None,ex_int_map)
ex_int_map.rbegin = new_instancemethod(_SyFi.ex_int_map_rbegin,None,ex_int_map)
ex_int_map.rend = new_instancemethod(_SyFi.ex_int_map_rend,None,ex_int_map)
ex_int_map.count = new_instancemethod(_SyFi.ex_int_map_count,None,ex_int_map)
ex_int_map.erase = new_instancemethod(_SyFi.ex_int_map_erase,None,ex_int_map)
ex_int_map.find = new_instancemethod(_SyFi.ex_int_map_find,None,ex_int_map)
ex_int_map.lower_bound = new_instancemethod(_SyFi.ex_int_map_lower_bound,None,ex_int_map)
ex_int_map.upper_bound = new_instancemethod(_SyFi.ex_int_map_upper_bound,None,ex_int_map)
ex_int_map_swigregister = _SyFi.ex_int_map_swigregister
ex_int_map_swigregister(ex_int_map)

class symexpair(object):
    """Proxy of C++ std::pair<(GiNaC::symbol,GiNaC::ex)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(std::pair<(GiNaC::symbol,GiNaC::ex)> self) -> symexpair
        __init__(std::pair<(GiNaC::symbol,GiNaC::ex)> self, GiNaC::symbol first, GiNaC::ex second) -> symexpair
        __init__(std::pair<(GiNaC::symbol,GiNaC::ex)> self, symexpair p) -> symexpair
        """
        _SyFi.symexpair_swiginit(self,_SyFi.new_symexpair(*args))
    first = _swig_property(_SyFi.symexpair_first_get, _SyFi.symexpair_first_set)
    second = _swig_property(_SyFi.symexpair_second_get, _SyFi.symexpair_second_set)
    def __len__(self): return 2
    def __repr__(self): return str((self.first, self.second))
    def __getitem__(self, index): 
      if not (index % 2): 
        return self.first
      else:
        return self.second
    def __setitem__(self, index, val):
      if not (index % 2): 
        self.first = val
      else:
        self.second = val
    __swig_destroy__ = _SyFi.delete_symexpair
symexpair_swigregister = _SyFi.symexpair_swigregister
symexpair_swigregister(symexpair)

class symexlist(object):
    """Proxy of C++ std::list<(std::pair<(GiNaC::symbol,GiNaC::ex)>)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(symexlist self) -> SwigPyIterator"""
        return _SyFi.symexlist_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(symexlist self) -> bool"""
        return _SyFi.symexlist___nonzero__(self)

    def __bool__(self):
        """__bool__(symexlist self) -> bool"""
        return _SyFi.symexlist___bool__(self)

    def __len__(self):
        """__len__(symexlist self) -> std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::size_type"""
        return _SyFi.symexlist___len__(self)

    def pop(self):
        """pop(symexlist self) -> symexpair"""
        return _SyFi.symexlist_pop(self)

    def __getslice__(self, *args):
        """__getslice__(symexlist self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::difference_type i, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::difference_type j) -> symexlist"""
        return _SyFi.symexlist___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(symexlist self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::difference_type i, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::difference_type j, 
            symexlist v=std::list< std::pair< GiNaC::symbol,GiNaC::ex >,std::allocator< std::pair< GiNaC::symbol,GiNaC::ex > > >())
        __setslice__(symexlist self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::difference_type i, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::difference_type j)
        """
        return _SyFi.symexlist___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(symexlist self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::difference_type i, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::difference_type j)"""
        return _SyFi.symexlist___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(symexlist self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::difference_type i)
        __delitem__(symexlist self, PySliceObject * slice)
        """
        return _SyFi.symexlist___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(symexlist self, PySliceObject * slice) -> symexlist
        __getitem__(symexlist self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::difference_type i) -> symexpair
        """
        return _SyFi.symexlist___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(symexlist self, PySliceObject * slice, symexlist v)
        __setitem__(symexlist self, PySliceObject * slice)
        __setitem__(symexlist self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::difference_type i, symexpair x)
        """
        return _SyFi.symexlist___setitem__(self, *args)

    def append(self, *args):
        """append(symexlist self, symexpair x)"""
        return _SyFi.symexlist_append(self, *args)

    def empty(self):
        """empty(symexlist self) -> bool"""
        return _SyFi.symexlist_empty(self)

    def size(self):
        """size(symexlist self) -> std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::size_type"""
        return _SyFi.symexlist_size(self)

    def clear(self):
        """clear(symexlist self)"""
        return _SyFi.symexlist_clear(self)

    def swap(self, *args):
        """swap(symexlist self, symexlist v)"""
        return _SyFi.symexlist_swap(self, *args)

    def get_allocator(self):
        """get_allocator(symexlist self) -> std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::allocator_type"""
        return _SyFi.symexlist_get_allocator(self)

    def begin(self):
        """begin(symexlist self) -> std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::iterator"""
        return _SyFi.symexlist_begin(self)

    def end(self):
        """end(symexlist self) -> std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::iterator"""
        return _SyFi.symexlist_end(self)

    def rbegin(self):
        """rbegin(symexlist self) -> std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::reverse_iterator"""
        return _SyFi.symexlist_rbegin(self)

    def rend(self):
        """rend(symexlist self) -> std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::reverse_iterator"""
        return _SyFi.symexlist_rend(self)

    def pop_back(self):
        """pop_back(symexlist self)"""
        return _SyFi.symexlist_pop_back(self)

    def erase(self, *args):
        """
        erase(symexlist self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::iterator pos) -> std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::iterator
        erase(symexlist self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::iterator first, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::iterator last) -> std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::iterator
        """
        return _SyFi.symexlist_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::list<(std::pair<(GiNaC::symbol,GiNaC::ex)>)> self) -> symexlist
        __init__(std::list<(std::pair<(GiNaC::symbol,GiNaC::ex)>)> self, symexlist arg2) -> symexlist
        __init__(std::list<(std::pair<(GiNaC::symbol,GiNaC::ex)>)> self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::size_type size) -> symexlist
        __init__(std::list<(std::pair<(GiNaC::symbol,GiNaC::ex)>)> self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::size_type size, symexpair value) -> symexlist
        """
        _SyFi.symexlist_swiginit(self,_SyFi.new_symexlist(*args))
    def push_back(self, *args):
        """push_back(symexlist self, symexpair x)"""
        return _SyFi.symexlist_push_back(self, *args)

    def front(self):
        """front(symexlist self) -> symexpair"""
        return _SyFi.symexlist_front(self)

    def back(self):
        """back(symexlist self) -> symexpair"""
        return _SyFi.symexlist_back(self)

    def assign(self, *args):
        """assign(symexlist self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::size_type n, symexpair x)"""
        return _SyFi.symexlist_assign(self, *args)

    def resize(self, *args):
        """
        resize(symexlist self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::size_type new_size)
        resize(symexlist self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::size_type new_size, symexpair x)
        """
        return _SyFi.symexlist_resize(self, *args)

    def insert(self, *args):
        """
        insert(symexlist self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::iterator pos, symexpair x) -> std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::iterator
        insert(symexlist self, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::iterator pos, std::list< std::pair< GiNaC::symbol,GiNaC::ex > >::size_type n, 
            symexpair x)
        """
        return _SyFi.symexlist_insert(self, *args)

    def pop_front(self):
        """pop_front(symexlist self)"""
        return _SyFi.symexlist_pop_front(self)

    def push_front(self, *args):
        """push_front(symexlist self, symexpair x)"""
        return _SyFi.symexlist_push_front(self, *args)

    def reverse(self):
        """reverse(symexlist self)"""
        return _SyFi.symexlist_reverse(self)

    __swig_destroy__ = _SyFi.delete_symexlist
symexlist.iterator = new_instancemethod(_SyFi.symexlist_iterator,None,symexlist)
symexlist.__nonzero__ = new_instancemethod(_SyFi.symexlist___nonzero__,None,symexlist)
symexlist.__bool__ = new_instancemethod(_SyFi.symexlist___bool__,None,symexlist)
symexlist.__len__ = new_instancemethod(_SyFi.symexlist___len__,None,symexlist)
symexlist.pop = new_instancemethod(_SyFi.symexlist_pop,None,symexlist)
symexlist.__getslice__ = new_instancemethod(_SyFi.symexlist___getslice__,None,symexlist)
symexlist.__setslice__ = new_instancemethod(_SyFi.symexlist___setslice__,None,symexlist)
symexlist.__delslice__ = new_instancemethod(_SyFi.symexlist___delslice__,None,symexlist)
symexlist.__delitem__ = new_instancemethod(_SyFi.symexlist___delitem__,None,symexlist)
symexlist.__getitem__ = new_instancemethod(_SyFi.symexlist___getitem__,None,symexlist)
symexlist.__setitem__ = new_instancemethod(_SyFi.symexlist___setitem__,None,symexlist)
symexlist.append = new_instancemethod(_SyFi.symexlist_append,None,symexlist)
symexlist.empty = new_instancemethod(_SyFi.symexlist_empty,None,symexlist)
symexlist.size = new_instancemethod(_SyFi.symexlist_size,None,symexlist)
symexlist.clear = new_instancemethod(_SyFi.symexlist_clear,None,symexlist)
symexlist.swap = new_instancemethod(_SyFi.symexlist_swap,None,symexlist)
symexlist.get_allocator = new_instancemethod(_SyFi.symexlist_get_allocator,None,symexlist)
symexlist.begin = new_instancemethod(_SyFi.symexlist_begin,None,symexlist)
symexlist.end = new_instancemethod(_SyFi.symexlist_end,None,symexlist)
symexlist.rbegin = new_instancemethod(_SyFi.symexlist_rbegin,None,symexlist)
symexlist.rend = new_instancemethod(_SyFi.symexlist_rend,None,symexlist)
symexlist.pop_back = new_instancemethod(_SyFi.symexlist_pop_back,None,symexlist)
symexlist.erase = new_instancemethod(_SyFi.symexlist_erase,None,symexlist)
symexlist.push_back = new_instancemethod(_SyFi.symexlist_push_back,None,symexlist)
symexlist.front = new_instancemethod(_SyFi.symexlist_front,None,symexlist)
symexlist.back = new_instancemethod(_SyFi.symexlist_back,None,symexlist)
symexlist.assign = new_instancemethod(_SyFi.symexlist_assign,None,symexlist)
symexlist.resize = new_instancemethod(_SyFi.symexlist_resize,None,symexlist)
symexlist.insert = new_instancemethod(_SyFi.symexlist_insert,None,symexlist)
symexlist.pop_front = new_instancemethod(_SyFi.symexlist_pop_front,None,symexlist)
symexlist.push_front = new_instancemethod(_SyFi.symexlist_push_front,None,symexlist)
symexlist.reverse = new_instancemethod(_SyFi.symexlist_reverse,None,symexlist)
symexlist_swigregister = _SyFi.symexlist_swigregister
symexlist_swigregister(symexlist)

class exlist(object):
    """Proxy of C++ std::list<(GiNaC::ex)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(exlist self) -> SwigPyIterator"""
        return _SyFi.exlist_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(exlist self) -> bool"""
        return _SyFi.exlist___nonzero__(self)

    def __bool__(self):
        """__bool__(exlist self) -> bool"""
        return _SyFi.exlist___bool__(self)

    def __len__(self):
        """__len__(exlist self) -> std::list< GiNaC::ex >::size_type"""
        return _SyFi.exlist___len__(self)

    def pop(self):
        """pop(exlist self) -> std::list< GiNaC::ex >::value_type"""
        return _SyFi.exlist_pop(self)

    def __getslice__(self, *args):
        """__getslice__(exlist self, std::list< GiNaC::ex >::difference_type i, std::list< GiNaC::ex >::difference_type j) -> exlist"""
        return _SyFi.exlist___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(exlist self, std::list< GiNaC::ex >::difference_type i, std::list< GiNaC::ex >::difference_type j, 
            exlist v=std::list< GiNaC::ex,std::allocator< GiNaC::ex > >())
        __setslice__(exlist self, std::list< GiNaC::ex >::difference_type i, std::list< GiNaC::ex >::difference_type j)
        """
        return _SyFi.exlist___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(exlist self, std::list< GiNaC::ex >::difference_type i, std::list< GiNaC::ex >::difference_type j)"""
        return _SyFi.exlist___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(exlist self, std::list< GiNaC::ex >::difference_type i)
        __delitem__(exlist self, PySliceObject * slice)
        """
        return _SyFi.exlist___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(exlist self, PySliceObject * slice) -> exlist
        __getitem__(exlist self, std::list< GiNaC::ex >::difference_type i) -> std::list< GiNaC::ex >::value_type const &
        """
        return _SyFi.exlist___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(exlist self, PySliceObject * slice, exlist v)
        __setitem__(exlist self, PySliceObject * slice)
        __setitem__(exlist self, std::list< GiNaC::ex >::difference_type i, std::list< GiNaC::ex >::value_type const & x)
        """
        return _SyFi.exlist___setitem__(self, *args)

    def append(self, *args):
        """append(exlist self, std::list< GiNaC::ex >::value_type const & x)"""
        return _SyFi.exlist_append(self, *args)

    def empty(self):
        """empty(exlist self) -> bool"""
        return _SyFi.exlist_empty(self)

    def size(self):
        """size(exlist self) -> std::list< GiNaC::ex >::size_type"""
        return _SyFi.exlist_size(self)

    def clear(self):
        """clear(exlist self)"""
        return _SyFi.exlist_clear(self)

    def swap(self, *args):
        """swap(exlist self, exlist v)"""
        return _SyFi.exlist_swap(self, *args)

    def get_allocator(self):
        """get_allocator(exlist self) -> std::list< GiNaC::ex >::allocator_type"""
        return _SyFi.exlist_get_allocator(self)

    def begin(self):
        """begin(exlist self) -> std::list< GiNaC::ex >::iterator"""
        return _SyFi.exlist_begin(self)

    def end(self):
        """end(exlist self) -> std::list< GiNaC::ex >::iterator"""
        return _SyFi.exlist_end(self)

    def rbegin(self):
        """rbegin(exlist self) -> std::list< GiNaC::ex >::reverse_iterator"""
        return _SyFi.exlist_rbegin(self)

    def rend(self):
        """rend(exlist self) -> std::list< GiNaC::ex >::reverse_iterator"""
        return _SyFi.exlist_rend(self)

    def pop_back(self):
        """pop_back(exlist self)"""
        return _SyFi.exlist_pop_back(self)

    def erase(self, *args):
        """
        erase(exlist self, std::list< GiNaC::ex >::iterator pos) -> std::list< GiNaC::ex >::iterator
        erase(exlist self, std::list< GiNaC::ex >::iterator first, std::list< GiNaC::ex >::iterator last) -> std::list< GiNaC::ex >::iterator
        """
        return _SyFi.exlist_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::list<(GiNaC::ex)> self) -> exlist
        __init__(std::list<(GiNaC::ex)> self, exlist arg2) -> exlist
        __init__(std::list<(GiNaC::ex)> self, std::list< GiNaC::ex >::size_type size) -> exlist
        __init__(std::list<(GiNaC::ex)> self, std::list< GiNaC::ex >::size_type size, std::list< GiNaC::ex >::value_type const & value) -> exlist
        """
        _SyFi.exlist_swiginit(self,_SyFi.new_exlist(*args))
    def push_back(self, *args):
        """push_back(exlist self, std::list< GiNaC::ex >::value_type const & x)"""
        return _SyFi.exlist_push_back(self, *args)

    def front(self):
        """front(exlist self) -> std::list< GiNaC::ex >::value_type const &"""
        return _SyFi.exlist_front(self)

    def back(self):
        """back(exlist self) -> std::list< GiNaC::ex >::value_type const &"""
        return _SyFi.exlist_back(self)

    def assign(self, *args):
        """assign(exlist self, std::list< GiNaC::ex >::size_type n, std::list< GiNaC::ex >::value_type const & x)"""
        return _SyFi.exlist_assign(self, *args)

    def resize(self, *args):
        """
        resize(exlist self, std::list< GiNaC::ex >::size_type new_size)
        resize(exlist self, std::list< GiNaC::ex >::size_type new_size, std::list< GiNaC::ex >::value_type const & x)
        """
        return _SyFi.exlist_resize(self, *args)

    def insert(self, *args):
        """
        insert(exlist self, std::list< GiNaC::ex >::iterator pos, std::list< GiNaC::ex >::value_type const & x) -> std::list< GiNaC::ex >::iterator
        insert(exlist self, std::list< GiNaC::ex >::iterator pos, std::list< GiNaC::ex >::size_type n, std::list< GiNaC::ex >::value_type const & x)
        """
        return _SyFi.exlist_insert(self, *args)

    def pop_front(self):
        """pop_front(exlist self)"""
        return _SyFi.exlist_pop_front(self)

    def push_front(self, *args):
        """push_front(exlist self, std::list< GiNaC::ex >::value_type const & x)"""
        return _SyFi.exlist_push_front(self, *args)

    def reverse(self):
        """reverse(exlist self)"""
        return _SyFi.exlist_reverse(self)

    __swig_destroy__ = _SyFi.delete_exlist
exlist.iterator = new_instancemethod(_SyFi.exlist_iterator,None,exlist)
exlist.__nonzero__ = new_instancemethod(_SyFi.exlist___nonzero__,None,exlist)
exlist.__bool__ = new_instancemethod(_SyFi.exlist___bool__,None,exlist)
exlist.__len__ = new_instancemethod(_SyFi.exlist___len__,None,exlist)
exlist.pop = new_instancemethod(_SyFi.exlist_pop,None,exlist)
exlist.__getslice__ = new_instancemethod(_SyFi.exlist___getslice__,None,exlist)
exlist.__setslice__ = new_instancemethod(_SyFi.exlist___setslice__,None,exlist)
exlist.__delslice__ = new_instancemethod(_SyFi.exlist___delslice__,None,exlist)
exlist.__delitem__ = new_instancemethod(_SyFi.exlist___delitem__,None,exlist)
exlist.__getitem__ = new_instancemethod(_SyFi.exlist___getitem__,None,exlist)
exlist.__setitem__ = new_instancemethod(_SyFi.exlist___setitem__,None,exlist)
exlist.append = new_instancemethod(_SyFi.exlist_append,None,exlist)
exlist.empty = new_instancemethod(_SyFi.exlist_empty,None,exlist)
exlist.size = new_instancemethod(_SyFi.exlist_size,None,exlist)
exlist.clear = new_instancemethod(_SyFi.exlist_clear,None,exlist)
exlist.swap = new_instancemethod(_SyFi.exlist_swap,None,exlist)
exlist.get_allocator = new_instancemethod(_SyFi.exlist_get_allocator,None,exlist)
exlist.begin = new_instancemethod(_SyFi.exlist_begin,None,exlist)
exlist.end = new_instancemethod(_SyFi.exlist_end,None,exlist)
exlist.rbegin = new_instancemethod(_SyFi.exlist_rbegin,None,exlist)
exlist.rend = new_instancemethod(_SyFi.exlist_rend,None,exlist)
exlist.pop_back = new_instancemethod(_SyFi.exlist_pop_back,None,exlist)
exlist.erase = new_instancemethod(_SyFi.exlist_erase,None,exlist)
exlist.push_back = new_instancemethod(_SyFi.exlist_push_back,None,exlist)
exlist.front = new_instancemethod(_SyFi.exlist_front,None,exlist)
exlist.back = new_instancemethod(_SyFi.exlist_back,None,exlist)
exlist.assign = new_instancemethod(_SyFi.exlist_assign,None,exlist)
exlist.resize = new_instancemethod(_SyFi.exlist_resize,None,exlist)
exlist.insert = new_instancemethod(_SyFi.exlist_insert,None,exlist)
exlist.pop_front = new_instancemethod(_SyFi.exlist_pop_front,None,exlist)
exlist.push_front = new_instancemethod(_SyFi.exlist_push_front,None,exlist)
exlist.reverse = new_instancemethod(_SyFi.exlist_reverse,None,exlist)
exlist_swigregister = _SyFi.exlist_swigregister
exlist_swigregister(exlist)

class exset(object):
    """Proxy of C++ std::set<(GiNaC::ex,GiNaC::ex_is_less)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(exset self) -> SwigPyIterator"""
        return _SyFi.exset_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(exset self) -> bool"""
        return _SyFi.exset___nonzero__(self)

    def __bool__(self):
        """__bool__(exset self) -> bool"""
        return _SyFi.exset___bool__(self)

    def __len__(self):
        """__len__(exset self) -> std::set< GiNaC::ex,GiNaC::ex_is_less >::size_type"""
        return _SyFi.exset___len__(self)

    def append(self, *args):
        """append(exset self, std::set< GiNaC::ex,GiNaC::ex_is_less >::value_type x)"""
        return _SyFi.exset_append(self, *args)

    def __contains__(self, *args):
        """__contains__(exset self, std::set< GiNaC::ex,GiNaC::ex_is_less >::value_type x) -> bool"""
        return _SyFi.exset___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(exset self, std::set< GiNaC::ex,GiNaC::ex_is_less >::difference_type i) -> std::set< GiNaC::ex,GiNaC::ex_is_less >::value_type"""
        return _SyFi.exset___getitem__(self, *args)

    def add(self, *args):
        """add(exset self, std::set< GiNaC::ex,GiNaC::ex_is_less >::value_type x)"""
        return _SyFi.exset_add(self, *args)

    def discard(self, *args):
        """discard(exset self, std::set< GiNaC::ex,GiNaC::ex_is_less >::value_type x)"""
        return _SyFi.exset_discard(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::set<(GiNaC::ex,GiNaC::ex_is_less)> self, GiNaC::ex_is_less const & arg2) -> exset
        __init__(std::set<(GiNaC::ex,GiNaC::ex_is_less)> self) -> exset
        __init__(std::set<(GiNaC::ex,GiNaC::ex_is_less)> self, exset arg2) -> exset
        """
        _SyFi.exset_swiginit(self,_SyFi.new_exset(*args))
    def empty(self):
        """empty(exset self) -> bool"""
        return _SyFi.exset_empty(self)

    def size(self):
        """size(exset self) -> std::set< GiNaC::ex,GiNaC::ex_is_less >::size_type"""
        return _SyFi.exset_size(self)

    def clear(self):
        """clear(exset self)"""
        return _SyFi.exset_clear(self)

    def swap(self, *args):
        """swap(exset self, exset v)"""
        return _SyFi.exset_swap(self, *args)

    def count(self, *args):
        """count(exset self, std::set< GiNaC::ex,GiNaC::ex_is_less >::key_type const & x) -> std::set< GiNaC::ex,GiNaC::ex_is_less >::size_type"""
        return _SyFi.exset_count(self, *args)

    def begin(self):
        """begin(exset self) -> std::set< GiNaC::ex,GiNaC::ex_is_less >::iterator"""
        return _SyFi.exset_begin(self)

    def end(self):
        """end(exset self) -> std::set< GiNaC::ex,GiNaC::ex_is_less >::iterator"""
        return _SyFi.exset_end(self)

    def rbegin(self):
        """rbegin(exset self) -> std::set< GiNaC::ex,GiNaC::ex_is_less >::reverse_iterator"""
        return _SyFi.exset_rbegin(self)

    def rend(self):
        """rend(exset self) -> std::set< GiNaC::ex,GiNaC::ex_is_less >::reverse_iterator"""
        return _SyFi.exset_rend(self)

    def erase(self, *args):
        """
        erase(exset self, std::set< GiNaC::ex,GiNaC::ex_is_less >::key_type const & x) -> std::set< GiNaC::ex,GiNaC::ex_is_less >::size_type
        erase(exset self, std::set< GiNaC::ex,GiNaC::ex_is_less >::iterator pos)
        erase(exset self, std::set< GiNaC::ex,GiNaC::ex_is_less >::iterator first, std::set< GiNaC::ex,GiNaC::ex_is_less >::iterator last)
        """
        return _SyFi.exset_erase(self, *args)

    def find(self, *args):
        """find(exset self, std::set< GiNaC::ex,GiNaC::ex_is_less >::key_type const & x) -> std::set< GiNaC::ex,GiNaC::ex_is_less >::iterator"""
        return _SyFi.exset_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(exset self, std::set< GiNaC::ex,GiNaC::ex_is_less >::key_type const & x) -> std::set< GiNaC::ex,GiNaC::ex_is_less >::iterator"""
        return _SyFi.exset_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(exset self, std::set< GiNaC::ex,GiNaC::ex_is_less >::key_type const & x) -> std::set< GiNaC::ex,GiNaC::ex_is_less >::iterator"""
        return _SyFi.exset_upper_bound(self, *args)

    def equal_range(self, *args):
        """equal_range(exset self, std::set< GiNaC::ex,GiNaC::ex_is_less >::key_type const & x) -> std::pair< std::set< GiNaC::ex,GiNaC::ex_is_less >::iterator,std::set< GiNaC::ex,GiNaC::ex_is_less >::iterator >"""
        return _SyFi.exset_equal_range(self, *args)

    def insert(self, *args):
        """insert(exset self, std::set< GiNaC::ex,GiNaC::ex_is_less >::value_type const & __x) -> std::pair< std::set< GiNaC::ex,GiNaC::ex_is_less >::iterator,bool >"""
        return _SyFi.exset_insert(self, *args)

    __swig_destroy__ = _SyFi.delete_exset
exset.iterator = new_instancemethod(_SyFi.exset_iterator,None,exset)
exset.__nonzero__ = new_instancemethod(_SyFi.exset___nonzero__,None,exset)
exset.__bool__ = new_instancemethod(_SyFi.exset___bool__,None,exset)
exset.__len__ = new_instancemethod(_SyFi.exset___len__,None,exset)
exset.append = new_instancemethod(_SyFi.exset_append,None,exset)
exset.__contains__ = new_instancemethod(_SyFi.exset___contains__,None,exset)
exset.__getitem__ = new_instancemethod(_SyFi.exset___getitem__,None,exset)
exset.add = new_instancemethod(_SyFi.exset_add,None,exset)
exset.discard = new_instancemethod(_SyFi.exset_discard,None,exset)
exset.empty = new_instancemethod(_SyFi.exset_empty,None,exset)
exset.size = new_instancemethod(_SyFi.exset_size,None,exset)
exset.clear = new_instancemethod(_SyFi.exset_clear,None,exset)
exset.swap = new_instancemethod(_SyFi.exset_swap,None,exset)
exset.count = new_instancemethod(_SyFi.exset_count,None,exset)
exset.begin = new_instancemethod(_SyFi.exset_begin,None,exset)
exset.end = new_instancemethod(_SyFi.exset_end,None,exset)
exset.rbegin = new_instancemethod(_SyFi.exset_rbegin,None,exset)
exset.rend = new_instancemethod(_SyFi.exset_rend,None,exset)
exset.erase = new_instancemethod(_SyFi.exset_erase,None,exset)
exset.find = new_instancemethod(_SyFi.exset_find,None,exset)
exset.lower_bound = new_instancemethod(_SyFi.exset_lower_bound,None,exset)
exset.upper_bound = new_instancemethod(_SyFi.exset_upper_bound,None,exset)
exset.equal_range = new_instancemethod(_SyFi.exset_equal_range,None,exset)
exset.insert = new_instancemethod(_SyFi.exset_insert,None,exset)
exset_swigregister = _SyFi.exset_swigregister
exset_swigregister(exset)


def dirac(*args):
  """dirac(unsigned int i, unsigned int j) -> int"""
  return _SyFi.dirac(*args)

def int2string(*args):
  """int2string(int i) -> std::string"""
  return _SyFi.int2string(*args)

def istr(*args):
  """
    istr(std::string const & a, int b) -> std::string
    istr(std::string const & a, int b, int c) -> std::string
    """
  return _SyFi.istr(*args)

def lst2string(*args):
  """lst2string(GiNaC::lst & l) -> std::string"""
  return _SyFi.lst2string(*args)

def div(*args):
  """
    div(GiNaC::lst & v) -> GiNaC::ex
    div(GiNaC::lst & v, GiNaC::ex G) -> GiNaC::ex
    div(GiNaC::ex v) -> GiNaC::ex
    div(GiNaC::ex v, GiNaC::ex G) -> GiNaC::ex
    """
  return _SyFi.div(*args)

def grad(*args):
  """
    grad(GiNaC::ex f) -> GiNaC::ex
    grad(GiNaC::ex f, GiNaC::ex G) -> GiNaC::ex
    """
  return _SyFi.grad(*args)

def compare(*args):
  """compare(GiNaC::ex const & e, std::string const & s) -> bool"""
  return _SyFi.compare(*args)

def EQUAL_OR_DIE(*args):
  """EQUAL_OR_DIE(GiNaC::ex const & e, std::string const & s)"""
  return _SyFi.EQUAL_OR_DIE(*args)

def compare_archives(*args):
  """
    compare_archives(std::string const & first, std::string const & second, std::ostream & os=std::cout) -> bool
    compare_archives(std::string const & first, std::string const & second) -> bool
    """
  return _SyFi.compare_archives(*args)

def inner(*args):
  """
    inner(GiNaC::ex a, GiNaC::ex b, bool transposed=False) -> GiNaC::ex
    inner(GiNaC::ex a, GiNaC::ex b) -> GiNaC::ex
    inner(GiNaC::exvector & v1, GiNaC::exvector & v2) -> GiNaC::ex
    inner(GiNaC::lst v1, GiNaC::lst v2) -> GiNaC::ex
    """
  return _SyFi.inner(*args)

def cross(*args):
  """cross(GiNaC::lst & v1, GiNaC::lst & v2) -> GiNaC::lst"""
  return _SyFi.cross(*args)

def matvec(*args):
  """
    matvec(GiNaC::matrix & M, GiNaC::lst & x) -> GiNaC::lst
    matvec(GiNaC::ex A, GiNaC::ex x) -> GiNaC::ex
    """
  return _SyFi.matvec(*args)

def ex2equations(*args):
  """ex2equations(GiNaC::ex rel) -> GiNaC::lst"""
  return _SyFi.ex2equations(*args)

def collapse(*args):
  """collapse(GiNaC::lst l) -> GiNaC::lst"""
  return _SyFi.collapse(*args)

def equations2matrix(*args):
  """equations2matrix(GiNaC::ex const & eqns, GiNaC::ex const & symbols) -> GiNaC::matrix"""
  return _SyFi.equations2matrix(*args)

def matrix_from_equations(*args):
  """matrix_from_equations(GiNaC::ex const & eqns, GiNaC::ex const & symbols, GiNaC::matrix & A, GiNaC::matrix & b)"""
  return _SyFi.matrix_from_equations(*args)

def lst_to_matrix2(*args):
  """lst_to_matrix2(GiNaC::lst const & l) -> GiNaC::ex"""
  return _SyFi.lst_to_matrix2(*args)

def matrix_to_lst2(*args):
  """matrix_to_lst2(GiNaC::ex const & m) -> GiNaC::lst"""
  return _SyFi.matrix_to_lst2(*args)

def lst_equals(*args):
  """lst_equals(GiNaC::ex a, GiNaC::ex b) -> GiNaC::lst"""
  return _SyFi.lst_equals(*args)

def find(*args):
  """find(GiNaC::ex e, GiNaC::lst list) -> int"""
  return _SyFi.find(*args)

def check_visitor(*args):
  """check_visitor(GiNaC::ex e, GiNaC::lst & exlist)"""
  return _SyFi.check_visitor(*args)

def visitor_subst_pow(*args):
  """visitor_subst_pow(GiNaC::ex e, GiNaC::exmap & map, ex_int_map intmap, std::string a)"""
  return _SyFi.visitor_subst_pow(*args)

def pol(*args):
  """pol(unsigned int order, unsigned int nsd, std::string const a) -> GiNaC::ex"""
  return _SyFi.pol(*args)

def polv(*args):
  """polv(unsigned int no_fields, unsigned int order, unsigned int nsd, std::string const a) -> GiNaC::lst"""
  return _SyFi.polv(*args)

def polb(*args):
  """polb(unsigned int order, unsigned int nsd, std::string const a) -> GiNaC::ex"""
  return _SyFi.polb(*args)

def homogenous_pol(*args):
  """homogenous_pol(unsigned int order, unsigned int nsd, std::string const a) -> GiNaC::ex"""
  return _SyFi.homogenous_pol(*args)

def homogenous_polv(*args):
  """homogenous_polv(unsigned int no_fields, unsigned int order, unsigned int nsd, std::string const a) -> GiNaC::lst"""
  return _SyFi.homogenous_polv(*args)

def legendre(*args):
  """legendre(unsigned int order, unsigned int nsd, std::string const a) -> GiNaC::ex"""
  return _SyFi.legendre(*args)

def legendrev(*args):
  """legendrev(unsigned int no_fields, unsigned int order, unsigned int nsd, std::string const a) -> GiNaC::lst"""
  return _SyFi.legendrev(*args)

def coeff(*args):
  """coeff(GiNaC::ex pol) -> GiNaC::exvector"""
  return _SyFi.coeff(*args)

def coeffs(*args):
  """
    coeffs(GiNaC::ex pol) -> GiNaC::lst
    coeffs(GiNaC::lst pols) -> GiNaC::lst
    """
  return _SyFi.coeffs(*args)

def pol2basisandcoeff(*args):
  """
    pol2basisandcoeff(GiNaC::ex e) -> GiNaC::exmap
    pol2basisandcoeff(GiNaC::ex e, GiNaC::ex s) -> GiNaC::exmap
    """
  return _SyFi.pol2basisandcoeff(*args)

def collect_symbols(*args):
  """
    collect_symbols(GiNaC::ex const & e, exset v)
    collect_symbols(GiNaC::ex const & e) -> GiNaC::exvector
    """
  return _SyFi.collect_symbols(*args)

def count_symbols(*args):
  """count_symbols(GiNaC::ex const & e) -> GiNaC::exhashmap< int >"""
  return _SyFi.count_symbols(*args)

def extract_symbols(*args):
  """extract_symbols(GiNaC::ex const & e) -> GiNaC::ex"""
  return _SyFi.extract_symbols(*args)
class ExStats(object):
    """Proxy of C++ SyFi::ExStats class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(SyFi::ExStats self) -> ExStats"""
        _SyFi.ExStats_swiginit(self,_SyFi.new_ExStats())
    def __iadd__(self, *args):
        """__iadd__(ExStats self, ExStats rhs) -> ExStats"""
        return _SyFi.ExStats___iadd__(self, *args)

    muls = _swig_property(_SyFi.ExStats_muls_get, _SyFi.ExStats_muls_set)
    adds = _swig_property(_SyFi.ExStats_adds_get, _SyFi.ExStats_adds_set)
    pows = _swig_property(_SyFi.ExStats_pows_get, _SyFi.ExStats_pows_set)
    functions = _swig_property(_SyFi.ExStats_functions_get, _SyFi.ExStats_functions_set)
    flops = _swig_property(_SyFi.ExStats_flops_get, _SyFi.ExStats_flops_set)
    __swig_destroy__ = _SyFi.delete_ExStats
ExStats.__iadd__ = new_instancemethod(_SyFi.ExStats___iadd__,None,ExStats)
ExStats_swigregister = _SyFi.ExStats_swigregister
ExStats_swigregister(ExStats)
cvar = _SyFi.cvar
version_major = cvar.version_major
version_minor = cvar.version_minor


def count_ops(*args):
  """count_ops(GiNaC::ex const & e) -> ExStats"""
  return _SyFi.count_ops(*args)

def replace_powers(*args):
  """
    replace_powers(GiNaC::ex const & e, std::list< GiNaC::symbol,std::allocator< GiNaC::symbol > > const & symbols, 
        symexlist sel, std::string const & tmpsymbolprefix="p_") -> GiNaC::ex
    replace_powers(GiNaC::ex const & e, std::list< GiNaC::symbol,std::allocator< GiNaC::symbol > > const & symbols, 
        symexlist sel) -> GiNaC::ex
    """
  return _SyFi.replace_powers(*args)

def initSyFi(*args):
  """initSyFi(unsigned int nsd)"""
  return _SyFi.initSyFi(*args)

def symbol_exists(*args):
  """symbol_exists(std::string const & name) -> bool"""
  return _SyFi.symbol_exists(*args)

def get_symbol(*args):
  """get_symbol(std::string const & name) -> GiNaC::symbol const &"""
  return _SyFi.get_symbol(*args)

def isymb(*args):
  """
    isymb(std::string const & a, int b) -> GiNaC::symbol const
    isymb(std::string const & a, int b, int c) -> GiNaC::symbol const &
    """
  return _SyFi.isymb(*args)

def get_symbolic_vector(*args):
  """get_symbolic_vector(int m, std::string const & basename) -> GiNaC::ex"""
  return _SyFi.get_symbolic_vector(*args)

def get_symbolic_matrix(*args):
  """get_symbolic_matrix(int m, int n, std::string const & basename) -> GiNaC::ex"""
  return _SyFi.get_symbolic_matrix(*args)
SUBS_PERFORMED = _SyFi.SUBS_PERFORMED
SUBS_NOT_PERFORMED = _SyFi.SUBS_NOT_PERFORMED
class Polygon(object):
    """Proxy of C++ SyFi::Polygon class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _SyFi.delete_Polygon
    def no_space_dim(self):
        """no_space_dim(Polygon self) -> unsigned int"""
        return _SyFi.Polygon_no_space_dim(self)

    def no_vertices(self):
        """no_vertices(Polygon self) -> unsigned int"""
        return _SyFi.Polygon_no_vertices(self)

    def vertex(self, *args):
        """vertex(Polygon self, unsigned int i) -> GiNaC::ex"""
        return _SyFi.Polygon_vertex(self, *args)

    def repr(self, *args):
        """
        repr(Polygon self, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        repr(Polygon self) -> GiNaC::ex
        """
        return _SyFi.Polygon_repr(self, *args)

    def str(self):
        """str(Polygon self) -> std::string const"""
        return _SyFi.Polygon_str(self)

    def integrate(self, *args):
        """
        integrate(Polygon self, GiNaC::ex f, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        integrate(Polygon self, GiNaC::ex f) -> GiNaC::ex
        """
        return _SyFi.Polygon_integrate(self, *args)

    def copy(self):
        """copy(Polygon self) -> Polygon"""
        return _SyFi.Polygon_copy(self)

    def line(self, *args):
        """line(Polygon self, unsigned int i) -> Line"""
        return _SyFi.Polygon_line(self, *args)

    def triangle(self, *args):
        """triangle(Polygon self, unsigned int i) -> Triangle"""
        return _SyFi.Polygon_triangle(self, *args)

    def rectangle(self, *args):
        """rectangle(Polygon self, unsigned int i) -> Rectangle"""
        return _SyFi.Polygon_rectangle(self, *args)

Polygon.no_space_dim = new_instancemethod(_SyFi.Polygon_no_space_dim,None,Polygon)
Polygon.no_vertices = new_instancemethod(_SyFi.Polygon_no_vertices,None,Polygon)
Polygon.vertex = new_instancemethod(_SyFi.Polygon_vertex,None,Polygon)
Polygon.repr = new_instancemethod(_SyFi.Polygon_repr,None,Polygon)
Polygon.str = new_instancemethod(_SyFi.Polygon_str,None,Polygon)
Polygon.integrate = new_instancemethod(_SyFi.Polygon_integrate,None,Polygon)
Polygon.copy = new_instancemethod(_SyFi.Polygon_copy,None,Polygon)
Polygon.line = new_instancemethod(_SyFi.Polygon_line,None,Polygon)
Polygon.triangle = new_instancemethod(_SyFi.Polygon_triangle,None,Polygon)
Polygon.rectangle = new_instancemethod(_SyFi.Polygon_rectangle,None,Polygon)
Polygon_swigregister = _SyFi.Polygon_swigregister
Polygon_swigregister(Polygon)

class Line(Polygon):
    """Proxy of C++ SyFi::Line class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::Line self) -> Line
        __init__(SyFi::Line self, GiNaC::ex x0, GiNaC::ex x1, std::string const & subscript="") -> Line
        __init__(SyFi::Line self, GiNaC::ex x0, GiNaC::ex x1) -> Line
        __init__(SyFi::Line self, Line line) -> Line
        """
        _SyFi.Line_swiginit(self,_SyFi.new_Line(*args))
    __swig_destroy__ = _SyFi.delete_Line
    def a(self):
        """a(Line self) -> GiNaC::ex"""
        return _SyFi.Line_a(self)

    def b(self):
        """b(Line self) -> GiNaC::ex"""
        return _SyFi.Line_b(self)

    def repr(self, *args):
        """
        repr(Line self, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        repr(Line self) -> GiNaC::ex
        repr(Line self, GiNaC::ex t, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        repr(Line self, GiNaC::ex t) -> GiNaC::ex
        """
        return _SyFi.Line_repr(self, *args)

    def integrate(self, *args):
        """
        integrate(Line self, GiNaC::ex f, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        integrate(Line self, GiNaC::ex f) -> GiNaC::ex
        """
        return _SyFi.Line_integrate(self, *args)

    def copy(self):
        """copy(Line self) -> Line"""
        return _SyFi.Line_copy(self)

Line.a = new_instancemethod(_SyFi.Line_a,None,Line)
Line.b = new_instancemethod(_SyFi.Line_b,None,Line)
Line.repr = new_instancemethod(_SyFi.Line_repr,None,Line)
Line.integrate = new_instancemethod(_SyFi.Line_integrate,None,Line)
Line.copy = new_instancemethod(_SyFi.Line_copy,None,Line)
Line_swigregister = _SyFi.Line_swigregister
Line_swigregister(Line)

class ReferenceLine(Line):
    """Proxy of C++ SyFi::ReferenceLine class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::ReferenceLine self, std::string const & subscript="") -> ReferenceLine
        __init__(SyFi::ReferenceLine self) -> ReferenceLine
        __init__(SyFi::ReferenceLine self, ReferenceLine line) -> ReferenceLine
        """
        _SyFi.ReferenceLine_swiginit(self,_SyFi.new_ReferenceLine(*args))
    __swig_destroy__ = _SyFi.delete_ReferenceLine
    def repr(self, *args):
        """
        repr(ReferenceLine self, GiNaC::ex t, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        repr(ReferenceLine self, GiNaC::ex t) -> GiNaC::ex
        """
        return _SyFi.ReferenceLine_repr(self, *args)

    def integrate(self, *args):
        """
        integrate(ReferenceLine self, GiNaC::ex f, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        integrate(ReferenceLine self, GiNaC::ex f) -> GiNaC::ex
        """
        return _SyFi.ReferenceLine_integrate(self, *args)

    def copy(self):
        """copy(ReferenceLine self) -> ReferenceLine"""
        return _SyFi.ReferenceLine_copy(self)

ReferenceLine.repr = new_instancemethod(_SyFi.ReferenceLine_repr,None,ReferenceLine)
ReferenceLine.integrate = new_instancemethod(_SyFi.ReferenceLine_integrate,None,ReferenceLine)
ReferenceLine.copy = new_instancemethod(_SyFi.ReferenceLine_copy,None,ReferenceLine)
ReferenceLine_swigregister = _SyFi.ReferenceLine_swigregister
ReferenceLine_swigregister(ReferenceLine)

class Triangle(Polygon):
    """Proxy of C++ SyFi::Triangle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::Triangle self, GiNaC::ex x0, GiNaC::ex x1, GiNaC::ex x2, std::string const & subscript="") -> Triangle
        __init__(SyFi::Triangle self, GiNaC::ex x0, GiNaC::ex x1, GiNaC::ex x2) -> Triangle
        __init__(SyFi::Triangle self, Triangle triangle) -> Triangle
        """
        _SyFi.Triangle_swiginit(self,_SyFi.new_Triangle(*args))
    __swig_destroy__ = _SyFi.delete_Triangle
    def repr(self, *args):
        """
        repr(Triangle self, SyFi::Repr_format arg2=SUBS_PERFORMED) -> GiNaC::ex
        repr(Triangle self) -> GiNaC::ex
        """
        return _SyFi.Triangle_repr(self, *args)

    def integrate(self, *args):
        """
        integrate(Triangle self, GiNaC::ex f, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        integrate(Triangle self, GiNaC::ex f) -> GiNaC::ex
        """
        return _SyFi.Triangle_integrate(self, *args)

    def copy(self):
        """copy(Triangle self) -> Triangle"""
        return _SyFi.Triangle_copy(self)

Triangle.repr = new_instancemethod(_SyFi.Triangle_repr,None,Triangle)
Triangle.integrate = new_instancemethod(_SyFi.Triangle_integrate,None,Triangle)
Triangle.copy = new_instancemethod(_SyFi.Triangle_copy,None,Triangle)
Triangle_swigregister = _SyFi.Triangle_swigregister
Triangle_swigregister(Triangle)

class ReferenceTriangle(Triangle):
    """Proxy of C++ SyFi::ReferenceTriangle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::ReferenceTriangle self, std::string const & subscript="") -> ReferenceTriangle
        __init__(SyFi::ReferenceTriangle self) -> ReferenceTriangle
        __init__(SyFi::ReferenceTriangle self, ReferenceTriangle triangle) -> ReferenceTriangle
        """
        _SyFi.ReferenceTriangle_swiginit(self,_SyFi.new_ReferenceTriangle(*args))
    __swig_destroy__ = _SyFi.delete_ReferenceTriangle
    def integrate(self, *args):
        """
        integrate(ReferenceTriangle self, GiNaC::ex f, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        integrate(ReferenceTriangle self, GiNaC::ex f) -> GiNaC::ex
        """
        return _SyFi.ReferenceTriangle_integrate(self, *args)

    def copy(self):
        """copy(ReferenceTriangle self) -> ReferenceTriangle"""
        return _SyFi.ReferenceTriangle_copy(self)

ReferenceTriangle.integrate = new_instancemethod(_SyFi.ReferenceTriangle_integrate,None,ReferenceTriangle)
ReferenceTriangle.copy = new_instancemethod(_SyFi.ReferenceTriangle_copy,None,ReferenceTriangle)
ReferenceTriangle_swigregister = _SyFi.ReferenceTriangle_swigregister
ReferenceTriangle_swigregister(ReferenceTriangle)

class Rectangle(Polygon):
    """Proxy of C++ SyFi::Rectangle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::Rectangle self, GiNaC::ex p0, GiNaC::ex p1, std::string const & subscript="") -> Rectangle
        __init__(SyFi::Rectangle self, GiNaC::ex p0, GiNaC::ex p1) -> Rectangle
        __init__(SyFi::Rectangle self, GiNaC::ex p0, GiNaC::ex p1, GiNaC::ex p2, GiNaC::ex p3, std::string const & subscript="") -> Rectangle
        __init__(SyFi::Rectangle self, GiNaC::ex p0, GiNaC::ex p1, GiNaC::ex p2, GiNaC::ex p3) -> Rectangle
        __init__(SyFi::Rectangle self, Rectangle rectangle) -> Rectangle
        """
        _SyFi.Rectangle_swiginit(self,_SyFi.new_Rectangle(*args))
    __swig_destroy__ = _SyFi.delete_Rectangle
    def repr(self, *args):
        """
        repr(Rectangle self, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        repr(Rectangle self) -> GiNaC::ex
        """
        return _SyFi.Rectangle_repr(self, *args)

    def integrate(self, *args):
        """
        integrate(Rectangle self, GiNaC::ex f, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        integrate(Rectangle self, GiNaC::ex f) -> GiNaC::ex
        """
        return _SyFi.Rectangle_integrate(self, *args)

    def copy(self):
        """copy(Rectangle self) -> Rectangle"""
        return _SyFi.Rectangle_copy(self)

Rectangle.repr = new_instancemethod(_SyFi.Rectangle_repr,None,Rectangle)
Rectangle.integrate = new_instancemethod(_SyFi.Rectangle_integrate,None,Rectangle)
Rectangle.copy = new_instancemethod(_SyFi.Rectangle_copy,None,Rectangle)
Rectangle_swigregister = _SyFi.Rectangle_swigregister
Rectangle_swigregister(Rectangle)

class ReferenceRectangle(Rectangle):
    """Proxy of C++ SyFi::ReferenceRectangle class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::ReferenceRectangle self, std::string const & subscript="") -> ReferenceRectangle
        __init__(SyFi::ReferenceRectangle self) -> ReferenceRectangle
        __init__(SyFi::ReferenceRectangle self, ReferenceRectangle rectangle) -> ReferenceRectangle
        """
        _SyFi.ReferenceRectangle_swiginit(self,_SyFi.new_ReferenceRectangle(*args))
    __swig_destroy__ = _SyFi.delete_ReferenceRectangle
    def copy(self):
        """copy(ReferenceRectangle self) -> ReferenceRectangle"""
        return _SyFi.ReferenceRectangle_copy(self)

ReferenceRectangle.copy = new_instancemethod(_SyFi.ReferenceRectangle_copy,None,ReferenceRectangle)
ReferenceRectangle_swigregister = _SyFi.ReferenceRectangle_swigregister
ReferenceRectangle_swigregister(ReferenceRectangle)

class Tetrahedron(Polygon):
    """Proxy of C++ SyFi::Tetrahedron class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::Tetrahedron self, GiNaC::ex x0, GiNaC::ex x1, GiNaC::ex x2, GiNaC::ex x3, std::string const & subscript="") -> Tetrahedron
        __init__(SyFi::Tetrahedron self, GiNaC::ex x0, GiNaC::ex x1, GiNaC::ex x2, GiNaC::ex x3) -> Tetrahedron
        __init__(SyFi::Tetrahedron self, Tetrahedron tetrahedron) -> Tetrahedron
        """
        _SyFi.Tetrahedron_swiginit(self,_SyFi.new_Tetrahedron(*args))
    __swig_destroy__ = _SyFi.delete_Tetrahedron
    def repr(self, *args):
        """
        repr(Tetrahedron self, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        repr(Tetrahedron self) -> GiNaC::ex
        """
        return _SyFi.Tetrahedron_repr(self, *args)

    def integrate(self, *args):
        """
        integrate(Tetrahedron self, GiNaC::ex f, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        integrate(Tetrahedron self, GiNaC::ex f) -> GiNaC::ex
        """
        return _SyFi.Tetrahedron_integrate(self, *args)

    def copy(self):
        """copy(Tetrahedron self) -> Tetrahedron"""
        return _SyFi.Tetrahedron_copy(self)

Tetrahedron.repr = new_instancemethod(_SyFi.Tetrahedron_repr,None,Tetrahedron)
Tetrahedron.integrate = new_instancemethod(_SyFi.Tetrahedron_integrate,None,Tetrahedron)
Tetrahedron.copy = new_instancemethod(_SyFi.Tetrahedron_copy,None,Tetrahedron)
Tetrahedron_swigregister = _SyFi.Tetrahedron_swigregister
Tetrahedron_swigregister(Tetrahedron)

class ReferenceTetrahedron(Tetrahedron):
    """Proxy of C++ SyFi::ReferenceTetrahedron class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::ReferenceTetrahedron self, std::string const & subscript="") -> ReferenceTetrahedron
        __init__(SyFi::ReferenceTetrahedron self) -> ReferenceTetrahedron
        __init__(SyFi::ReferenceTetrahedron self, ReferenceTetrahedron tetrahedron) -> ReferenceTetrahedron
        """
        _SyFi.ReferenceTetrahedron_swiginit(self,_SyFi.new_ReferenceTetrahedron(*args))
    __swig_destroy__ = _SyFi.delete_ReferenceTetrahedron
    def integrate(self, *args):
        """
        integrate(ReferenceTetrahedron self, GiNaC::ex f, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        integrate(ReferenceTetrahedron self, GiNaC::ex f) -> GiNaC::ex
        """
        return _SyFi.ReferenceTetrahedron_integrate(self, *args)

    def copy(self):
        """copy(ReferenceTetrahedron self) -> ReferenceTetrahedron"""
        return _SyFi.ReferenceTetrahedron_copy(self)

ReferenceTetrahedron.integrate = new_instancemethod(_SyFi.ReferenceTetrahedron_integrate,None,ReferenceTetrahedron)
ReferenceTetrahedron.copy = new_instancemethod(_SyFi.ReferenceTetrahedron_copy,None,ReferenceTetrahedron)
ReferenceTetrahedron_swigregister = _SyFi.ReferenceTetrahedron_swigregister
ReferenceTetrahedron_swigregister(ReferenceTetrahedron)

class Box(Polygon):
    """Proxy of C++ SyFi::Box class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::Box self, GiNaC::ex p0, GiNaC::ex p1, std::string const & subscript="") -> Box
        __init__(SyFi::Box self, GiNaC::ex p0, GiNaC::ex p1) -> Box
        __init__(SyFi::Box self, GiNaC::ex p0, GiNaC::ex p1, GiNaC::ex p2, GiNaC::ex p3, GiNaC::ex p4, GiNaC::ex p5, 
            GiNaC::ex p6, GiNaC::ex p7, std::string const & subscript="") -> Box
        __init__(SyFi::Box self, GiNaC::ex p0, GiNaC::ex p1, GiNaC::ex p2, GiNaC::ex p3, GiNaC::ex p4, GiNaC::ex p5, 
            GiNaC::ex p6, GiNaC::ex p7) -> Box
        __init__(SyFi::Box self, Box box) -> Box
        __init__(SyFi::Box self) -> Box
        """
        _SyFi.Box_swiginit(self,_SyFi.new_Box(*args))
    __swig_destroy__ = _SyFi.delete_Box
    def repr(self, *args):
        """
        repr(Box self, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        repr(Box self) -> GiNaC::ex
        """
        return _SyFi.Box_repr(self, *args)

    def integrate(self, *args):
        """
        integrate(Box self, GiNaC::ex f, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        integrate(Box self, GiNaC::ex f) -> GiNaC::ex
        """
        return _SyFi.Box_integrate(self, *args)

    def copy(self):
        """copy(Box self) -> Box"""
        return _SyFi.Box_copy(self)

Box.repr = new_instancemethod(_SyFi.Box_repr,None,Box)
Box.integrate = new_instancemethod(_SyFi.Box_integrate,None,Box)
Box.copy = new_instancemethod(_SyFi.Box_copy,None,Box)
Box_swigregister = _SyFi.Box_swigregister
Box_swigregister(Box)

class ReferenceBox(Box):
    """Proxy of C++ SyFi::ReferenceBox class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::ReferenceBox self, std::string const & subscript="") -> ReferenceBox
        __init__(SyFi::ReferenceBox self) -> ReferenceBox
        __init__(SyFi::ReferenceBox self, ReferenceBox box) -> ReferenceBox
        """
        _SyFi.ReferenceBox_swiginit(self,_SyFi.new_ReferenceBox(*args))
    __swig_destroy__ = _SyFi.delete_ReferenceBox
    def copy(self):
        """copy(ReferenceBox self) -> ReferenceBox"""
        return _SyFi.ReferenceBox_copy(self)

ReferenceBox.copy = new_instancemethod(_SyFi.ReferenceBox_copy,None,ReferenceBox)
ReferenceBox_swigregister = _SyFi.ReferenceBox_swigregister
ReferenceBox_swigregister(ReferenceBox)

class Simplex(Polygon):
    """Proxy of C++ SyFi::Simplex class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::Simplex self, GiNaC::lst vertices, std::string const & subscript="") -> Simplex
        __init__(SyFi::Simplex self, GiNaC::lst vertices) -> Simplex
        __init__(SyFi::Simplex self, Simplex simplex) -> Simplex
        """
        _SyFi.Simplex_swiginit(self,_SyFi.new_Simplex(*args))
    __swig_destroy__ = _SyFi.delete_Simplex
    def repr(self, *args):
        """
        repr(Simplex self, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        repr(Simplex self) -> GiNaC::ex
        """
        return _SyFi.Simplex_repr(self, *args)

    def integrate(self, *args):
        """
        integrate(Simplex self, GiNaC::ex f, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        integrate(Simplex self, GiNaC::ex f) -> GiNaC::ex
        """
        return _SyFi.Simplex_integrate(self, *args)

    def sub_simplex(self, *args):
        """sub_simplex(Simplex self, unsigned int i) -> Simplex"""
        return _SyFi.Simplex_sub_simplex(self, *args)

    def copy(self):
        """copy(Simplex self) -> Simplex"""
        return _SyFi.Simplex_copy(self)

Simplex.repr = new_instancemethod(_SyFi.Simplex_repr,None,Simplex)
Simplex.integrate = new_instancemethod(_SyFi.Simplex_integrate,None,Simplex)
Simplex.sub_simplex = new_instancemethod(_SyFi.Simplex_sub_simplex,None,Simplex)
Simplex.copy = new_instancemethod(_SyFi.Simplex_copy,None,Simplex)
Simplex_swigregister = _SyFi.Simplex_swigregister
Simplex_swigregister(Simplex)


def barycenter_line(*args):
  """barycenter_line(GiNaC::ex p0, GiNaC::ex p1) -> GiNaC::ex"""
  return _SyFi.barycenter_line(*args)

def barycenter_triangle(*args):
  """barycenter_triangle(GiNaC::ex p0, GiNaC::ex p1, GiNaC::ex p2) -> GiNaC::ex"""
  return _SyFi.barycenter_triangle(*args)

def barycenter_tetrahedron(*args):
  """barycenter_tetrahedron(GiNaC::ex p0, GiNaC::ex p1, GiNaC::ex p2, GiNaC::ex p3) -> GiNaC::ex"""
  return _SyFi.barycenter_tetrahedron(*args)

def barycenter(*args):
  """barycenter(Simplex simplex) -> GiNaC::ex"""
  return _SyFi.barycenter(*args)

def bezier_ordinates(*args):
  """
    bezier_ordinates(Line line, unsigned int d) -> GiNaC::lst
    bezier_ordinates(Triangle triangle, unsigned int d) -> GiNaC::lst
    bezier_ordinates(Tetrahedron tetrahedra, unsigned int d) -> GiNaC::lst
    """
  return _SyFi.bezier_ordinates(*args)

def interior_coordinates(*args):
  """
    interior_coordinates(Line line, unsigned int d) -> GiNaC::lst
    interior_coordinates(Triangle triangle, unsigned int d) -> GiNaC::lst
    interior_coordinates(Tetrahedron tetrahedra, unsigned int d) -> GiNaC::lst
    """
  return _SyFi.interior_coordinates(*args)

def bernstein(*args):
  """bernstein(unsigned int order, Polygon p, std::string const & a) -> GiNaC::ex"""
  return _SyFi.bernstein(*args)

def bernsteinv(*args):
  """bernsteinv(unsigned int no_fields, unsigned int order, Polygon p, std::string const & a) -> GiNaC::lst"""
  return _SyFi.bernsteinv(*args)

def normal(*args):
  """
    normal(Triangle arg1, unsigned int i) -> GiNaC::lst
    normal(Tetrahedron arg1, unsigned int i) -> GiNaC::lst
    """
  return _SyFi.normal(*args)

def tangent(*args):
  """tangent(Triangle arg1, unsigned int i) -> GiNaC::lst"""
  return _SyFi.tangent(*args)
class FE(object):
    """Proxy of C++ SyFi::FE class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _SyFi.delete_FE
    def set_polygon(self, *args):
        """set_polygon(FE self, Polygon p)"""
        return _SyFi.FE_set_polygon(self, *args)

    def get_polygon(self):
        """get_polygon(FE self) -> Polygon"""
        return _SyFi.FE_get_polygon(self)

    def compute_basis_functions(self):
        """compute_basis_functions(FE self)"""
        return _SyFi.FE_compute_basis_functions(self)

    def nbf(self):
        """nbf(FE self) -> unsigned int"""
        return _SyFi.FE_nbf(self)

    def N(self, *args):
        """N(FE self, unsigned int i) -> GiNaC::ex"""
        return _SyFi.FE_N(self, *args)

    def dof(self, *args):
        """dof(FE self, unsigned int i) -> GiNaC::ex"""
        return _SyFi.FE_dof(self, *args)

    def str(self):
        """str(FE self) -> std::string"""
        return _SyFi.FE_str(self)

FE.set_polygon = new_instancemethod(_SyFi.FE_set_polygon,None,FE)
FE.get_polygon = new_instancemethod(_SyFi.FE_get_polygon,None,FE)
FE.compute_basis_functions = new_instancemethod(_SyFi.FE_compute_basis_functions,None,FE)
FE.nbf = new_instancemethod(_SyFi.FE_nbf,None,FE)
FE.N = new_instancemethod(_SyFi.FE_N,None,FE)
FE.dof = new_instancemethod(_SyFi.FE_dof,None,FE)
FE.str = new_instancemethod(_SyFi.FE_str,None,FE)
FE_swigregister = _SyFi.FE_swigregister
FE_swigregister(FE)

class StandardFE(FE):
    """Proxy of C++ SyFi::StandardFE class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::StandardFE self) -> StandardFE
        __init__(SyFi::StandardFE self, Polygon p, unsigned int order) -> StandardFE
        """
        _SyFi.StandardFE_swiginit(self,_SyFi.new_StandardFE(*args))
    __swig_destroy__ = _SyFi.delete_StandardFE
    def set_order(self, *args):
        """set_order(StandardFE self, unsigned int order)"""
        return _SyFi.StandardFE_set_order(self, *args)

    def get_order(self):
        """get_order(StandardFE self) -> unsigned int"""
        return _SyFi.StandardFE_get_order(self)

StandardFE.set_order = new_instancemethod(_SyFi.StandardFE_set_order,None,StandardFE)
StandardFE.get_order = new_instancemethod(_SyFi.StandardFE_get_order,None,StandardFE)
StandardFE_swigregister = _SyFi.StandardFE_swigregister
StandardFE_swigregister(StandardFE)

class Lagrange(StandardFE):
    """Proxy of C++ SyFi::Lagrange class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::Lagrange self) -> Lagrange
        __init__(SyFi::Lagrange self, Polygon p, unsigned int order=1) -> Lagrange
        __init__(SyFi::Lagrange self, Polygon p) -> Lagrange
        """
        _SyFi.Lagrange_swiginit(self,_SyFi.new_Lagrange(*args))
    __swig_destroy__ = _SyFi.delete_Lagrange
Lagrange_swigregister = _SyFi.Lagrange_swigregister
Lagrange_swigregister(Lagrange)

class VectorLagrange(StandardFE):
    """Proxy of C++ SyFi::VectorLagrange class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::VectorLagrange self) -> VectorLagrange
        __init__(SyFi::VectorLagrange self, Polygon p, unsigned int order=1, unsigned int size=0) -> VectorLagrange
        __init__(SyFi::VectorLagrange self, Polygon p, unsigned int order=1) -> VectorLagrange
        __init__(SyFi::VectorLagrange self, Polygon p) -> VectorLagrange
        """
        _SyFi.VectorLagrange_swiginit(self,_SyFi.new_VectorLagrange(*args))
    __swig_destroy__ = _SyFi.delete_VectorLagrange
    def set_size(self, *args):
        """set_size(VectorLagrange self, unsigned int size_)"""
        return _SyFi.VectorLagrange_set_size(self, *args)

VectorLagrange.set_size = new_instancemethod(_SyFi.VectorLagrange_set_size,None,VectorLagrange)
VectorLagrange_swigregister = _SyFi.VectorLagrange_swigregister
VectorLagrange_swigregister(VectorLagrange)

class TensorLagrange(StandardFE):
    """Proxy of C++ SyFi::TensorLagrange class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::TensorLagrange self) -> TensorLagrange
        __init__(SyFi::TensorLagrange self, Polygon p, unsigned int order=1, unsigned int size=0) -> TensorLagrange
        __init__(SyFi::TensorLagrange self, Polygon p, unsigned int order=1) -> TensorLagrange
        __init__(SyFi::TensorLagrange self, Polygon p) -> TensorLagrange
        """
        _SyFi.TensorLagrange_swiginit(self,_SyFi.new_TensorLagrange(*args))
    __swig_destroy__ = _SyFi.delete_TensorLagrange
    def set_size(self, *args):
        """set_size(TensorLagrange self, unsigned int size_)"""
        return _SyFi.TensorLagrange_set_size(self, *args)

TensorLagrange.set_size = new_instancemethod(_SyFi.TensorLagrange_set_size,None,TensorLagrange)
TensorLagrange_swigregister = _SyFi.TensorLagrange_swigregister
TensorLagrange_swigregister(TensorLagrange)


def lagrange(*args):
  """lagrange(unsigned int order, Polygon p, std::string const & a) -> GiNaC::ex"""
  return _SyFi.lagrange(*args)

def lagrangev(*args):
  """lagrangev(unsigned int no_fields, unsigned int order, Polygon p, std::string const & a) -> GiNaC::lst"""
  return _SyFi.lagrangev(*args)
class Dof(object):
    """Proxy of C++ SyFi::Dof class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, create_glob2dof=False, create_glob2loc=False): 
        """
        __init__(SyFi::Dof self, bool create_glob2dof=False, bool create_glob2loc=False) -> Dof
        __init__(SyFi::Dof self, bool create_glob2dof=False) -> Dof
        __init__(SyFi::Dof self) -> Dof
        """
        _SyFi.Dof_swiginit(self,_SyFi.new_Dof(create_glob2dof, create_glob2loc))
    __swig_destroy__ = _SyFi.delete_Dof
    def clear(self):
        """clear(Dof self)"""
        return _SyFi.Dof_clear(self)

    def insert_dof(self, *args):
        """insert_dof(Dof self, unsigned int e, unsigned int i, GiNaC::ex Li) -> unsigned int"""
        return _SyFi.Dof_insert_dof(self, *args)

    def size(self):
        """size(Dof self) -> unsigned int"""
        return _SyFi.Dof_size(self)

    def num_elements(self):
        """num_elements(Dof self) -> unsigned int"""
        return _SyFi.Dof_num_elements(self)

    def max_dofs_per_element(self):
        """max_dofs_per_element(Dof self) -> unsigned int"""
        return _SyFi.Dof_max_dofs_per_element(self)

    def glob_dof(self, *args):
        """
        glob_dof(Dof self, unsigned int e, unsigned int i) -> unsigned int
        glob_dof(Dof self, GiNaC::ex Lj) -> unsigned int
        glob_dof(Dof self, unsigned int j) -> GiNaC::ex
        """
        return _SyFi.Dof_glob_dof(self, *args)

    def glob2loc(self, *args):
        """glob2loc(Dof self, unsigned int j) -> SyFi::vector_ii"""
        return _SyFi.Dof_glob2loc(self, *args)

Dof.clear = new_instancemethod(_SyFi.Dof_clear,None,Dof)
Dof.insert_dof = new_instancemethod(_SyFi.Dof_insert_dof,None,Dof)
Dof.size = new_instancemethod(_SyFi.Dof_size,None,Dof)
Dof.num_elements = new_instancemethod(_SyFi.Dof_num_elements,None,Dof)
Dof.max_dofs_per_element = new_instancemethod(_SyFi.Dof_max_dofs_per_element,None,Dof)
Dof.glob_dof = new_instancemethod(_SyFi.Dof_glob_dof,None,Dof)
Dof.glob2loc = new_instancemethod(_SyFi.Dof_glob2loc,None,Dof)
Dof_swigregister = _SyFi.Dof_swigregister
Dof_swigregister(Dof)

class CrouzeixRaviart(StandardFE):
    """Proxy of C++ SyFi::CrouzeixRaviart class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::CrouzeixRaviart self) -> CrouzeixRaviart
        __init__(SyFi::CrouzeixRaviart self, Polygon p, unsigned int order=1) -> CrouzeixRaviart
        __init__(SyFi::CrouzeixRaviart self, Polygon p) -> CrouzeixRaviart
        """
        _SyFi.CrouzeixRaviart_swiginit(self,_SyFi.new_CrouzeixRaviart(*args))
    __swig_destroy__ = _SyFi.delete_CrouzeixRaviart
CrouzeixRaviart_swigregister = _SyFi.CrouzeixRaviart_swigregister
CrouzeixRaviart_swigregister(CrouzeixRaviart)

class VectorCrouzeixRaviart(StandardFE):
    """Proxy of C++ SyFi::VectorCrouzeixRaviart class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::VectorCrouzeixRaviart self) -> VectorCrouzeixRaviart
        __init__(SyFi::VectorCrouzeixRaviart self, Polygon p, unsigned int order=1, unsigned int size=-1) -> VectorCrouzeixRaviart
        __init__(SyFi::VectorCrouzeixRaviart self, Polygon p, unsigned int order=1) -> VectorCrouzeixRaviart
        __init__(SyFi::VectorCrouzeixRaviart self, Polygon p) -> VectorCrouzeixRaviart
        """
        _SyFi.VectorCrouzeixRaviart_swiginit(self,_SyFi.new_VectorCrouzeixRaviart(*args))
    __swig_destroy__ = _SyFi.delete_VectorCrouzeixRaviart
    def set_size(self, *args):
        """set_size(VectorCrouzeixRaviart self, unsigned int size_)"""
        return _SyFi.VectorCrouzeixRaviart_set_size(self, *args)

VectorCrouzeixRaviart.set_size = new_instancemethod(_SyFi.VectorCrouzeixRaviart_set_size,None,VectorCrouzeixRaviart)
VectorCrouzeixRaviart_swigregister = _SyFi.VectorCrouzeixRaviart_swigregister
VectorCrouzeixRaviart_swigregister(VectorCrouzeixRaviart)

class P0(StandardFE):
    """Proxy of C++ SyFi::P0 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::P0 self) -> P0
        __init__(SyFi::P0 self, Polygon p, unsigned int order=0) -> P0
        __init__(SyFi::P0 self, Polygon p) -> P0
        """
        _SyFi.P0_swiginit(self,_SyFi.new_P0(*args))
    __swig_destroy__ = _SyFi.delete_P0
P0_swigregister = _SyFi.P0_swigregister
P0_swigregister(P0)

class VectorP0(StandardFE):
    """Proxy of C++ SyFi::VectorP0 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::VectorP0 self) -> VectorP0
        __init__(SyFi::VectorP0 self, Polygon p, unsigned int order=0, unsigned int size=0) -> VectorP0
        __init__(SyFi::VectorP0 self, Polygon p, unsigned int order=0) -> VectorP0
        __init__(SyFi::VectorP0 self, Polygon p) -> VectorP0
        """
        _SyFi.VectorP0_swiginit(self,_SyFi.new_VectorP0(*args))
    __swig_destroy__ = _SyFi.delete_VectorP0
    def set_size(self, *args):
        """set_size(VectorP0 self, unsigned int size_)"""
        return _SyFi.VectorP0_set_size(self, *args)

VectorP0.set_size = new_instancemethod(_SyFi.VectorP0_set_size,None,VectorP0)
VectorP0_swigregister = _SyFi.VectorP0_swigregister
VectorP0_swigregister(VectorP0)

class TensorP0(StandardFE):
    """Proxy of C++ SyFi::TensorP0 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::TensorP0 self) -> TensorP0
        __init__(SyFi::TensorP0 self, Polygon p, unsigned int order=0, unsigned int size=0) -> TensorP0
        __init__(SyFi::TensorP0 self, Polygon p, unsigned int order=0) -> TensorP0
        __init__(SyFi::TensorP0 self, Polygon p) -> TensorP0
        """
        _SyFi.TensorP0_swiginit(self,_SyFi.new_TensorP0(*args))
    __swig_destroy__ = _SyFi.delete_TensorP0
    def set_size(self, *args):
        """set_size(TensorP0 self, unsigned int size_)"""
        return _SyFi.TensorP0_set_size(self, *args)

TensorP0.set_size = new_instancemethod(_SyFi.TensorP0_set_size,None,TensorP0)
TensorP0_swigregister = _SyFi.TensorP0_swigregister
TensorP0_swigregister(TensorP0)

class RaviartThomas(StandardFE):
    """Proxy of C++ SyFi::RaviartThomas class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    pointwise = _swig_property(_SyFi.RaviartThomas_pointwise_get, _SyFi.RaviartThomas_pointwise_set)
    dof_repr = _swig_property(_SyFi.RaviartThomas_dof_repr_get, _SyFi.RaviartThomas_dof_repr_set)
    def __init__(self, *args): 
        """
        __init__(SyFi::RaviartThomas self) -> RaviartThomas
        __init__(SyFi::RaviartThomas self, Polygon p, int order=1, bool pointwise=True) -> RaviartThomas
        __init__(SyFi::RaviartThomas self, Polygon p, int order=1) -> RaviartThomas
        __init__(SyFi::RaviartThomas self, Polygon p) -> RaviartThomas
        """
        _SyFi.RaviartThomas_swiginit(self,_SyFi.new_RaviartThomas(*args))
    __swig_destroy__ = _SyFi.delete_RaviartThomas
RaviartThomas_swigregister = _SyFi.RaviartThomas_swigregister
RaviartThomas_swigregister(RaviartThomas)

class DiscontinuousLagrange(Lagrange):
    """Proxy of C++ SyFi::DiscontinuousLagrange class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::DiscontinuousLagrange self) -> DiscontinuousLagrange
        __init__(SyFi::DiscontinuousLagrange self, Polygon p, unsigned int order=1) -> DiscontinuousLagrange
        __init__(SyFi::DiscontinuousLagrange self, Polygon p) -> DiscontinuousLagrange
        """
        _SyFi.DiscontinuousLagrange_swiginit(self,_SyFi.new_DiscontinuousLagrange(*args))
    __swig_destroy__ = _SyFi.delete_DiscontinuousLagrange
    def set_element_number(self, *args):
        """set_element_number(DiscontinuousLagrange self, unsigned int element)"""
        return _SyFi.DiscontinuousLagrange_set_element_number(self, *args)

DiscontinuousLagrange.set_element_number = new_instancemethod(_SyFi.DiscontinuousLagrange_set_element_number,None,DiscontinuousLagrange)
DiscontinuousLagrange_swigregister = _SyFi.DiscontinuousLagrange_swigregister
DiscontinuousLagrange_swigregister(DiscontinuousLagrange)

class VectorDiscontinuousLagrange(VectorLagrange):
    """Proxy of C++ SyFi::VectorDiscontinuousLagrange class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::VectorDiscontinuousLagrange self) -> VectorDiscontinuousLagrange
        __init__(SyFi::VectorDiscontinuousLagrange self, Polygon p, unsigned int order=1) -> VectorDiscontinuousLagrange
        __init__(SyFi::VectorDiscontinuousLagrange self, Polygon p) -> VectorDiscontinuousLagrange
        """
        _SyFi.VectorDiscontinuousLagrange_swiginit(self,_SyFi.new_VectorDiscontinuousLagrange(*args))
    __swig_destroy__ = _SyFi.delete_VectorDiscontinuousLagrange
    def set_element_number(self, *args):
        """set_element_number(VectorDiscontinuousLagrange self, unsigned int element)"""
        return _SyFi.VectorDiscontinuousLagrange_set_element_number(self, *args)

VectorDiscontinuousLagrange.set_element_number = new_instancemethod(_SyFi.VectorDiscontinuousLagrange_set_element_number,None,VectorDiscontinuousLagrange)
VectorDiscontinuousLagrange_swigregister = _SyFi.VectorDiscontinuousLagrange_swigregister
VectorDiscontinuousLagrange_swigregister(VectorDiscontinuousLagrange)

class Hermite(StandardFE):
    """Proxy of C++ SyFi::Hermite class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::Hermite self) -> Hermite
        __init__(SyFi::Hermite self, Polygon p, int order=1) -> Hermite
        __init__(SyFi::Hermite self, Polygon p) -> Hermite
        """
        _SyFi.Hermite_swiginit(self,_SyFi.new_Hermite(*args))
    __swig_destroy__ = _SyFi.delete_Hermite
Hermite_swigregister = _SyFi.Hermite_swigregister
Hermite_swigregister(Hermite)

class Nedelec(StandardFE):
    """Proxy of C++ SyFi::Nedelec class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::Nedelec self) -> Nedelec
        __init__(SyFi::Nedelec self, Polygon p, int order=1) -> Nedelec
        __init__(SyFi::Nedelec self, Polygon p) -> Nedelec
        """
        _SyFi.Nedelec_swiginit(self,_SyFi.new_Nedelec(*args))
    __swig_destroy__ = _SyFi.delete_Nedelec
Nedelec_swigregister = _SyFi.Nedelec_swigregister
Nedelec_swigregister(Nedelec)

class Nedelec2Hdiv(StandardFE):
    """Proxy of C++ SyFi::Nedelec2Hdiv class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    dof_repr = _swig_property(_SyFi.Nedelec2Hdiv_dof_repr_get, _SyFi.Nedelec2Hdiv_dof_repr_set)
    def __init__(self, *args): 
        """
        __init__(SyFi::Nedelec2Hdiv self) -> Nedelec2Hdiv
        __init__(SyFi::Nedelec2Hdiv self, Polygon p, unsigned int order=1) -> Nedelec2Hdiv
        __init__(SyFi::Nedelec2Hdiv self, Polygon p) -> Nedelec2Hdiv
        """
        _SyFi.Nedelec2Hdiv_swiginit(self,_SyFi.new_Nedelec2Hdiv(*args))
    __swig_destroy__ = _SyFi.delete_Nedelec2Hdiv
Nedelec2Hdiv_swigregister = _SyFi.Nedelec2Hdiv_swigregister
Nedelec2Hdiv_swigregister(Nedelec2Hdiv)

class Bubble(StandardFE):
    """Proxy of C++ SyFi::Bubble class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::Bubble self) -> Bubble
        __init__(SyFi::Bubble self, Polygon p, unsigned int order=3) -> Bubble
        __init__(SyFi::Bubble self, Polygon p) -> Bubble
        """
        _SyFi.Bubble_swiginit(self,_SyFi.new_Bubble(*args))
    __swig_destroy__ = _SyFi.delete_Bubble
Bubble_swigregister = _SyFi.Bubble_swigregister
Bubble_swigregister(Bubble)


def usage(*args):
  """
    usage(FE fe)
    usage(FE v_fe, FE p_fe)
    """
  return _SyFi.usage(*args)

def compute_Poisson_element_matrix(*args):
  """compute_Poisson_element_matrix(FE fe, Dof dof, std::map< std::pair< unsigned int,unsigned int >,GiNaC::ex,std::less< std::pair< unsigned int,unsigned int > >,std::allocator< std::pair< std::pair< unsigned int,unsigned int > const,GiNaC::ex > > > & A)"""
  return _SyFi.compute_Poisson_element_matrix(*args)

def compute_Stokes_element_matrix(*args):
  """compute_Stokes_element_matrix(FE v_fe, FE p_fe, Dof dof, std::map< std::pair< unsigned int,unsigned int >,GiNaC::ex,std::less< std::pair< unsigned int,unsigned int > >,std::allocator< std::pair< std::pair< unsigned int,unsigned int > const,GiNaC::ex > > > & A)"""
  return _SyFi.compute_Stokes_element_matrix(*args)

def compute_mixed_Poisson_element_matrix(*args):
  """compute_mixed_Poisson_element_matrix(FE v_fe, FE p_fe, Dof dof, std::map< std::pair< unsigned int,unsigned int >,GiNaC::ex,std::less< std::pair< unsigned int,unsigned int > >,std::allocator< std::pair< std::pair< unsigned int,unsigned int > const,GiNaC::ex > > > & A)"""
  return _SyFi.compute_mixed_Poisson_element_matrix(*args)
class ArnoldFalkWintherWeakSymSigma(StandardFE):
    """Proxy of C++ SyFi::ArnoldFalkWintherWeakSymSigma class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::ArnoldFalkWintherWeakSymSigma self) -> ArnoldFalkWintherWeakSymSigma
        __init__(SyFi::ArnoldFalkWintherWeakSymSigma self, Polygon p, int order=1) -> ArnoldFalkWintherWeakSymSigma
        __init__(SyFi::ArnoldFalkWintherWeakSymSigma self, Polygon p) -> ArnoldFalkWintherWeakSymSigma
        """
        _SyFi.ArnoldFalkWintherWeakSymSigma_swiginit(self,_SyFi.new_ArnoldFalkWintherWeakSymSigma(*args))
    __swig_destroy__ = _SyFi.delete_ArnoldFalkWintherWeakSymSigma
ArnoldFalkWintherWeakSymSigma_swigregister = _SyFi.ArnoldFalkWintherWeakSymSigma_swigregister
ArnoldFalkWintherWeakSymSigma_swigregister(ArnoldFalkWintherWeakSymSigma)

class ArnoldFalkWintherWeakSymU(StandardFE):
    """Proxy of C++ SyFi::ArnoldFalkWintherWeakSymU class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::ArnoldFalkWintherWeakSymU self) -> ArnoldFalkWintherWeakSymU
        __init__(SyFi::ArnoldFalkWintherWeakSymU self, Polygon p, int order=1) -> ArnoldFalkWintherWeakSymU
        __init__(SyFi::ArnoldFalkWintherWeakSymU self, Polygon p) -> ArnoldFalkWintherWeakSymU
        """
        _SyFi.ArnoldFalkWintherWeakSymU_swiginit(self,_SyFi.new_ArnoldFalkWintherWeakSymU(*args))
    __swig_destroy__ = _SyFi.delete_ArnoldFalkWintherWeakSymU
ArnoldFalkWintherWeakSymU_swigregister = _SyFi.ArnoldFalkWintherWeakSymU_swigregister
ArnoldFalkWintherWeakSymU_swigregister(ArnoldFalkWintherWeakSymU)

class ArnoldFalkWintherWeakSymP(StandardFE):
    """Proxy of C++ SyFi::ArnoldFalkWintherWeakSymP class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::ArnoldFalkWintherWeakSymP self) -> ArnoldFalkWintherWeakSymP
        __init__(SyFi::ArnoldFalkWintherWeakSymP self, Polygon p, int order=1) -> ArnoldFalkWintherWeakSymP
        __init__(SyFi::ArnoldFalkWintherWeakSymP self, Polygon p) -> ArnoldFalkWintherWeakSymP
        """
        _SyFi.ArnoldFalkWintherWeakSymP_swiginit(self,_SyFi.new_ArnoldFalkWintherWeakSymP(*args))
    __swig_destroy__ = _SyFi.delete_ArnoldFalkWintherWeakSymP
ArnoldFalkWintherWeakSymP_swigregister = _SyFi.ArnoldFalkWintherWeakSymP_swigregister
ArnoldFalkWintherWeakSymP_swigregister(ArnoldFalkWintherWeakSymP)

class Robust(StandardFE):
    """Proxy of C++ SyFi::Robust class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    pointwise = _swig_property(_SyFi.Robust_pointwise_get, _SyFi.Robust_pointwise_set)
    dof_repr = _swig_property(_SyFi.Robust_dof_repr_get, _SyFi.Robust_dof_repr_set)
    def __init__(self, *args): 
        """
        __init__(SyFi::Robust self) -> Robust
        __init__(SyFi::Robust self, Polygon p, unsigned int order=0, bool pointwise=True) -> Robust
        __init__(SyFi::Robust self, Polygon p, unsigned int order=0) -> Robust
        __init__(SyFi::Robust self, Polygon p) -> Robust
        """
        _SyFi.Robust_swiginit(self,_SyFi.new_Robust(*args))
    __swig_destroy__ = _SyFi.delete_Robust
    def compute_basis_functions_old(self):
        """compute_basis_functions_old(Robust self)"""
        return _SyFi.Robust_compute_basis_functions_old(self)

Robust.compute_basis_functions_old = new_instancemethod(_SyFi.Robust_compute_basis_functions_old,None,Robust)
Robust_swigregister = _SyFi.Robust_swigregister
Robust_swigregister(Robust)

class MixedFE(FE):
    """Proxy of C++ SyFi::MixedFE class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    mfe = _swig_property(_SyFi.MixedFE_mfe_get, _SyFi.MixedFE_mfe_set)
    def __init__(self, *args): 
        """
        __init__(SyFi::MixedFE self) -> MixedFE
        __init__(SyFi::MixedFE self, StandardFE fe1, StandardFE fe2) -> MixedFE
        """
        _SyFi.MixedFE_swiginit(self,_SyFi.new_MixedFE(*args))
    __swig_destroy__ = _SyFi.delete_MixedFE
    def get(self, *args):
        """get(MixedFE self, unsigned int i) -> StandardFE"""
        return _SyFi.MixedFE_get(self, *args)

    def append(self, *args):
        """append(MixedFE self, StandardFE fe)"""
        return _SyFi.MixedFE_append(self, *args)

MixedFE.get = new_instancemethod(_SyFi.MixedFE_get,None,MixedFE)
MixedFE.append = new_instancemethod(_SyFi.MixedFE_append,None,MixedFE)
MixedFE_swigregister = _SyFi.MixedFE_swigregister
MixedFE_swigregister(MixedFE)

class SpaceTimeDomain(Polygon):
    """Proxy of C++ SyFi::SpaceTimeDomain class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::SpaceTimeDomain self, Line time_line_, Polygon polygon_) -> SpaceTimeDomain
        __init__(SyFi::SpaceTimeDomain self, SpaceTimeDomain space_time_domain_) -> SpaceTimeDomain
        """
        _SyFi.SpaceTimeDomain_swiginit(self,_SyFi.new_SpaceTimeDomain(*args))
    def get_space_domain(self):
        """get_space_domain(SpaceTimeDomain self) -> Polygon"""
        return _SyFi.SpaceTimeDomain_get_space_domain(self)

    def get_time_domain(self):
        """get_time_domain(SpaceTimeDomain self) -> Line"""
        return _SyFi.SpaceTimeDomain_get_time_domain(self)

    def repr(self, *args):
        """
        repr(SpaceTimeDomain self, SyFi::Repr_format arg2=SUBS_PERFORMED) -> GiNaC::ex
        repr(SpaceTimeDomain self) -> GiNaC::ex
        """
        return _SyFi.SpaceTimeDomain_repr(self, *args)

    def integrate(self, *args):
        """
        integrate(SpaceTimeDomain self, GiNaC::ex f, SyFi::Repr_format format=SUBS_PERFORMED) -> GiNaC::ex
        integrate(SpaceTimeDomain self, GiNaC::ex f) -> GiNaC::ex
        """
        return _SyFi.SpaceTimeDomain_integrate(self, *args)

    def copy(self):
        """copy(SpaceTimeDomain self) -> SpaceTimeDomain"""
        return _SyFi.SpaceTimeDomain_copy(self)

    __swig_destroy__ = _SyFi.delete_SpaceTimeDomain
SpaceTimeDomain.get_space_domain = new_instancemethod(_SyFi.SpaceTimeDomain_get_space_domain,None,SpaceTimeDomain)
SpaceTimeDomain.get_time_domain = new_instancemethod(_SyFi.SpaceTimeDomain_get_time_domain,None,SpaceTimeDomain)
SpaceTimeDomain.repr = new_instancemethod(_SyFi.SpaceTimeDomain_repr,None,SpaceTimeDomain)
SpaceTimeDomain.integrate = new_instancemethod(_SyFi.SpaceTimeDomain_integrate,None,SpaceTimeDomain)
SpaceTimeDomain.copy = new_instancemethod(_SyFi.SpaceTimeDomain_copy,None,SpaceTimeDomain)
SpaceTimeDomain_swigregister = _SyFi.SpaceTimeDomain_swigregister
SpaceTimeDomain_swigregister(SpaceTimeDomain)

class SpaceTimeElement(StandardFE):
    """Proxy of C++ SyFi::SpaceTimeElement class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(SyFi::SpaceTimeElement self) -> SpaceTimeElement
        __init__(SyFi::SpaceTimeElement self, Line time_line_, unsigned int order_, StandardFE fe_) -> SpaceTimeElement
        """
        _SyFi.SpaceTimeElement_swiginit(self,_SyFi.new_SpaceTimeElement(*args))
    __swig_destroy__ = _SyFi.delete_SpaceTimeElement
    def set_time_domain(self, *args):
        """set_time_domain(SpaceTimeElement self, Line line)"""
        return _SyFi.SpaceTimeElement_set_time_domain(self, *args)

    def set_order_in_time(self, *args):
        """set_order_in_time(SpaceTimeElement self, unsigned int order)"""
        return _SyFi.SpaceTimeElement_set_order_in_time(self, *args)

    def set_spatial_element(self, *args):
        """set_spatial_element(SpaceTimeElement self, StandardFE fe)"""
        return _SyFi.SpaceTimeElement_set_spatial_element(self, *args)

SpaceTimeElement.set_time_domain = new_instancemethod(_SyFi.SpaceTimeElement_set_time_domain,None,SpaceTimeElement)
SpaceTimeElement.set_order_in_time = new_instancemethod(_SyFi.SpaceTimeElement_set_order_in_time,None,SpaceTimeElement)
SpaceTimeElement.set_spatial_element = new_instancemethod(_SyFi.SpaceTimeElement_set_spatial_element,None,SpaceTimeElement)
SpaceTimeElement_swigregister = _SyFi.SpaceTimeElement_swigregister
SpaceTimeElement_swigregister(SpaceTimeElement)